dump
Definition
-- @/lua/common/utils.lua:127
function dump(...)
-- to find out who is calling this, you can use this snippet:
--log('A', "lua.utils.dump-calledby", debug.traceback())
log('A', "lua.utils", dumps(...))
end
Callers
@/lua/ge/extensions/editor/gen/terrain.lua
end
U.dump(f2p, '<< corr:')
end
local r = math.floor(f2r*(fma-f)/(fma-fmi)*tersize.x + 0.5)
U.dump(p, '?? waveUp:'..f..':'..r)
-- if true then return end
end
U.dump(aregion, '?? for_areg:')
-- U.dump(aregion, '>> regionPlot:'..#aregion)
U.dump(aregion, '?? for_areg:')
-- U.dump(aregion, '>> regionPlot:'..#aregion)
mask = {}
-- check being close
-- U.dump(path[i], '?? if_close:')
local dist,pp = U.toLine(path[i].p, {a,b})
if dist < path[i].w/2+margin/2 and U.vang(U.mod(i+1,path).p-path[i].p, pp-path[i].p, true)>0 then
-- U.dump(dhit,'??^^^^^^^^^^ is_CLOSE:'..i..':'..tostring(pp)..':'..U.vang(U.mod(i+1,path).p-path[i].p,pp-path[i].p,true)) --..':'..tostring(pp-a)..':'..tostring(d-c)..':'..tostring(path[i].w))
-- toMark({path[i].p}, 'blue', nil, 0.1, 1)
-- ahit[#ahit+1] = {p=p, ang=U.vang(p-a, d-c, true), w=path[i].w}
-- U.dump(ahit, '?? CLOSE_dhit:'..tostring(b))
if #ahit == 3 then
toMark(ahit, 'green', function(d) return d.p end, 0.08, 0.6)
U.dump(ahit, '?? for_HIT:'..#ahit)
for i,d in pairs(ahit) do
if inends then
-- U.dump(ahit, '?? end_H:')
return ahit
local h1,h2 = ahit[i],ahit[i+1]
-- U.dump(h1, '?? hit1:'..i..':'..tostring(ahit[i].p))
-- U.dump(h2, '?? hit2:'..i..':'..tostring(ahit[i].p))
-- U.dump(h1, '?? hit1:'..i..':'..tostring(ahit[i].p))
-- U.dump(h2, '?? hit2:'..i..':'..tostring(ahit[i].p))
local list = {
-- aseg[#aseg+1] = list
if dbg then U.dump(list, '?? hit2slice:'..i) end
aslice[#aslice+1] = list
-- get starting point
-- U.dump(loop[imi].seg, '?? if_corner:'..loop[imi].seg.ind..':'..U.mod(imi-1,loop).seg.ind)
-- U.dump(loop[imi].seg, )
-- U.dump(loop[imi].seg, '?? if_corner:'..loop[imi].seg.ind..':'..U.mod(imi-1,loop).seg.ind)
-- U.dump(loop[imi].seg, )
local cb = forCorner(imi, margin)
-- lo('?? sectorPlot:'..tostring(b))
-- U.dump(b, '?? sectorPlot:'..tostring(b))
-- toMark(b.list, 'yel')
lo('!! ERR_crossNext:'..tostring(ni)..':'..tostring(ni == 1 and dsc.jfr or dsc.jto)..':'..#ajunc)
-- U.dump(dsc, '!! ERR_crossNext:'..tostring(ni)..':'..tostring(ni == 1 and dsc.jfr or dsc.jto)..':'..#ajunc)
return
if adec[b.ind].isline then
-- U.dump(b, '?? for_bst:'..k..':'..b.jfr)
dir = cb.list[#cb.list]-cb.list[1]
--TODO: multiple split
-- U.dump(dsplit, '?? for_SPLIT:'..#dsplit)
]]
-- U.dump(s, '??+++++++++++++++++ to_EXT:')
-- U.dump(ahit, '??+++++++++++++++++ to_EXT:'..d1..':'..d2)
-- U.dump(s, '??+++++++++++++++++ to_EXT:')
-- U.dump(ahit, '??+++++++++++++++++ to_EXT:'..d1..':'..d2)
--[[
if not v.w then
U.dump(v, '?? no_W:'..t)
toMark({loop[1].p}, 'cyan', nil, 0.1, 1)
-- lo('?? if_LOOP:'..#loop..':'..n)
-- U.dump(loop,'?? if_LOOP:'..#loop)
-- table.remove(loop,#loop)
lo('>> roadPlace:'..tableSize(mask)..':'..iR)
-- U.dump(mask)
local am1 = {}
end
U.dump(aregion, '?? roadPlace_areg:')
local outputFile = io.open('./tmp/reg_save_'..tostring(os.clock())..'.json', "w")
-- if #ari == 3 then
-- U.dump(ari, '?? to_ARI:'..i..':'..j..':'..tostring(cr)..':'..val)
-- am1[#am1+1] = toWorld(j,i)
dnode[stamp][ord][#dnode[stamp][ord]+1] = vec3(j,i)
-- U.dump(ari, '?? for_cross:')
end
end
-- U.dump(dnode, '?? for_dnode:')
local ap = {}
end
-- U.dump(anode, '?? pre_merge_ap:')
-- toMark(ap, 'cyan', nil, 0.2)
goon = true
U.dump(anode[i], '??++++++++++++++++++++++++ merged:')
break
end
U.dump(anode, '?? post_merge_ap:')
-- toMark(anode,'red',function(d) return d.p end)
]]
-- U.dump(r.star, '?? for_star:'..i)
end
end
U.dump(aseg, '?? for_ASEG:')
-- place decals
if key == '6_2' then
U.dump(pth, '?? 6_2:'..ni..':'..nito)
D.decalPlot(pth)
if true then
-- U.dump(pth, '??____ prePATH:')
local desc = D.decalPlot(pth, D.default.laneWidth*(#s.areg==1 and 4 or 3), adec)
lo('?? for_OUT:'..s.areg[1])
-- U.dump(reg.arad, '??++++++++++++++++++++++++++++ arad:')
local rmi = 0
-- local ne = s.desc.body:getEdgeCount()
-- U.dump(s.desc, '?? pre_SPLIT:'..tostring(s.desc.body)..':'..ne)
-- pair = D.decalSplit(s.desc, pmi,true)
lst,ajunc,across = D.decalsLoad(adec)
-- U.dump(ajunc,'?? pre_LOAD:'..#am1..':'..#adec)
-- APPEND valency-2 junctions
if junc.p:distance(reg.p) < 1 then
-- U.dump(junc, '?? toJ set:'..i)
junc.list = reg.arad
lo('?? post_LOAD:'..#lst..':'..#ajunc..':'..#adec)
-- U.dump(ajunc[1], '?? for_ADEC:'..#list..':'..#ajunc)
-- U.dump(ajunc, '?? for_ADEC:'..#list..':'..#ajunc)
-- U.dump(ajunc[1], '?? for_ADEC:'..#list..':'..#ajunc)
-- U.dump(ajunc, '?? for_ADEC:'..#list..':'..#ajunc)
-- toMark(am1, 'mag', nil, 0.1, 1)
-- toMark(am1, 'mag', nil, 0.1, 1)
-- U.dump(adec[1], '?? dec:')
-- build lattice
-- toMark(ajunc,'red',function(d) return d.p end, 0.1, 1)
-- U.dump(across, '?? across:')
for t,reg in pairs(aregion) do
if (not dbc or #dbc==0) or (dbc and t==dbc[1]) then
-- U.dump(reg.arad, '?? for_REG:'..i)
-- lo('?? for_JUNC:'..#ajunc)
-- lo('?? for_SEC:'..t..':'..i)
-- U.dump(adec[b.ind], '?? if_line:'..i..':'..tostring(adec[b.ind].isline))
if (not dbc or #dbc==0) or (dbc and i==dbc[2]) then
local function crossNext_(deci, ni)
U.dump(across[deci][ni], '?? crossNext:'..deci..':'..ni)
toMark({adec[deci].list[ni]}, 'mag', nil, 0.2, 1)
if adec[b.ind].isline then
-- U.dump(b, '?? for_bst:'..k..':'..b.jfr)
dir = cb.list[#cb.list]-cb.list[1]
lo('?? if_LOOP:'..#loop..':'..n)
-- U.dump(loop,'?? if_LOOP:'..#loop)
-- table.remove(loop,#loop)
]]
-- U.dump(adec[b.ind], '??^^^^^^^^^^^^^^ for_P:'.._..':'..tostring(reg.p))
-- local bnxt = crossNext(b, 2)
-- U.dump(across[b.ind], '?? ')
-- forNext(loop, adec[b.ind].list)
-- loop[#loop+1] = dir == 1 and seg.list[#seg.list] or
-- U.dump(across[b.ind], '?? for_branch:'..i)
-- toMark(loop, 'yel', function(d)
-- U.dump(c.list,'?? SLICE:'..#c.list..':'.._..':'..tostring(c.p))
-- U.dump(c.list,'?? SLICE2:'..#c.list)
-- U.dump(c.list,'?? SLICE:'..#c.list..':'.._..':'..tostring(c.p))
-- U.dump(c.list,'?? SLICE2:'..#c.list)
--[[
end
U.dump(aseg, '?? aSEG:')
-- place decals
d.p.z = forZ(d.p)
-- U.dump(d, '?? for_reg:')
end
end
U.dump(aregion, '?? for_reg:')
T.out.aregion = aregion
end
U.dump(dw, '<< test:')
wav2ter(dw)
-- lo('<< Ter.wheel:')
-- U.dump(aregion, '?? Ter.wheel:')
-- return true
@/lua/ge/extensions/career/modules/delivery/cargoScreen.lua
--dump(materialType, cargoType, amount, targetLocation)
for _, cargo in ipairs(list) do
--dump(cargoId, cargo.id)
if cargo.id == cargoId then
if cargo.id == cargoId then
--dump(poiId)
--dump(freeroam_bigMapMode.navigateToMission(poiId))
--dump(poiId)
--dump(freeroam_bigMapMode.navigateToMission(poiId))
return
--print(cargo.name .. " -> ")
--dump(target)
if target.type == "facilityParkingspot" then
@/lua/ge/extensions/editor/gen/exp_meshexplorer.lua
W.jpartSort = function(ajpart, col, dir)
-- dump(ajpart, '>> jpartSort:',nil,2)
table.sort(ajpart, function(a,b)
end)
-- dump(ajpart, '<< jpartSort:',nil,2)
end
end
-- dump(ageopin, '<< partPin:')
end
local cstr,cdef,cspr,cdam = 0,0,0,0
-- dump(beamdata.abeampick,'?? for_BEAMS_p:')
for i,b in pairs(beamdata.abeampick) do
dparam.damp = grp.damp or 100
-- dump(dparam, '?? dparam:')
end
if d.key == key and d.abeam then
-- dump(d.abeam,'?? for_BM:'..tostring(#d.abeam))
return U.map(d.abeam,function(k,v)
end)
-- dump(apath, '?? if_PATH:')
-- U.out.agraph[1] = {list=apath,c={1,1,0,0.6}, w=2, z=false}
end
-- dump(beamdata.anode[b.av[1]],'?? node:')
-- break
end)
-- dump(beamdata.agroup, '<< partUp:',nil,2)
end
local pvd = extensions.core_vehicle_manager.getPlayerVehicleData()
-- dump(pvd.config,'?? PVD:'..tostring(pvd.config),nil)
local dbeam = M.forBeams(pvd.vdata.beams)
local bb = dbeam['pickup_axle_R'][2].body
dump(bb, '?? beam[1]:')
dump(pvd.vdata.nodes[bb.id1], '?? bb_1:')
dump(bb, '?? beam[1]:')
dump(pvd.vdata.nodes[bb.id1], '?? bb_1:')
dump(pvd.vdata.nodes[bb.id2], '?? bb_2:')
dump(pvd.vdata.nodes[bb.id1], '?? bb_1:')
dump(pvd.vdata.nodes[bb.id2], '?? bb_2:')
-- dump(pvd.vdata.activePartsData['pickup_axle_R'],'?? PVD:',nil)
dump(pvd.vdata.nodes[bb.id2], '?? bb_2:')
-- dump(pvd.vdata.activePartsData['pickup_axle_R'],'?? PVD:',nil)
-- vdata: groups, components, +activePartsData, activeParts, information, props
local vehData = core_vehicle_manager.getVehicleData(id)
dump(vehData.ioCtx.preloadedDirs,'?? vehData:'..tostring(vehData.ioCtx))
-- local pfmap = jbeamIO.getPFMap()
-- local pfmap = jbeamIO.getPFMap()
-- dump(pfmap, '?? PFMAP:',nil,2)
jbeamIO.startLoading(vehData.ioCtx.preloadedDirs)
if d.model_key == 'pickup' then
-- dump(d,'?? OD:'..j) --..tostring(d.offsetData))
-- lo('?? OD:'..j..':'..d.pcFilename) --..tostring(d.offsetData))
c={0,1,1},w=0.01}
-- dump(ac, '?? if_LINE:'..tostring(r))
U.out.aset[3] = {set = {vec3(ac[1],ac[2],ac[3]),vec3(ac[4],ac[5],ac[6])},w=0.01}
-- .beamDamp .beamDeform .beamSpring .beamLimitSpring .beamStrength
-- dump(pvd.vdata.beams, '?? vdata_rn:'..tostring(pvd.vdata.refNodes.ref)..':'..#pvd.vdata.nodes..':'..tostring(pvd.vdata.nodes[pvd.vdata.refNodes[0].ref].pos),nil,2)
-- dump(pvd.vdata.variables, '?? vdata_var:',nil,2)
-- dump(pvd.vdata.beams, '?? vdata_rn:'..tostring(pvd.vdata.refNodes.ref)..':'..#pvd.vdata.nodes..':'..tostring(pvd.vdata.nodes[pvd.vdata.refNodes[0].ref].pos),nil,2)
-- dump(pvd.vdata.variables, '?? vdata_var:',nil,2)
for id, veh in activeVehiclesIterator() do
-- dump(dbeam['pickup_hood'], '?? dbeam:',nil,2)
-- beamdata.m = daedata.dgeo[31].m
end)
dump(apath[1], '?? apath3:'..#apath)
U.out.agraph[1] = {
local am = M.gpuFrom(pvd.id)
-- dump(dbeam, '?? dbeam:'..#pvd.vdata.beams..':'..tableSize(dbeam), nil, 1)
-- dump(am, '?? ageo:'..tableSize(am),nil, 1)
-- dump(dbeam, '?? dbeam:'..#pvd.vdata.beams..':'..tableSize(dbeam), nil, 1)
-- dump(am, '?? ageo:'..tableSize(am),nil, 1)
-- local s = 0
for _,v in pairs(m.verts) do
-- dump(a, '?? for_v:'..tostring(v))
local d = v:distance(a.pos)
if not hit then
-- dump(b[1].av, '?? miss:'..k..':'..tostring(b[1]), nil, 1)
end
dump(daedata.ageo[31], '?? ageo_31:',nil, 2)
beamdata.m = daedata.dgeo[31].m
local pvd = vehManager.getPlayerVehicleData()
dump(pvd,'?? PV:'..pvd.id..':'..#pvd.vdata.beams..':'..#pvd.vdata.nodes,nil,1) --:getId())
local av = pvd.vdata.nodes
if true then
-- dump(b, '?? for_BEAM:'..k)
return {av[b.id1].pos,av[b.id2].pos}
U.out.agraph[1] = {list=apath, c={1,0,0,0.2}, w=2,z=false}
-- dump(U.out.agraph[1].list,'?? apath:'..tostring(apath[1][1])..'/'..#apath)
-- for i,b in pairs(pvd.vdata.beams) do
local model = core_vehicles.getModel(config.model_key).model
-- if _ == 1 then dump(config, '?? for_MODEL:'..tostring(config.model_key)) end
local icn = editor.texObj(config['preview'])
if _==36 or _==37 then
dump(icn, '?? for_ICN:'.._)
end
end
-- if _ == 1 then dump(icn, '?? for_MODEL:'..tostring(config.model_key)) end
if icn.file ~= 'empty.jpg' then
lo('?? NIN:'..#amodel..':'..tableSize(dimg)..'/'..#data.configs)
-- dump(dimg, '?? if_TILES:'..tostring(data))
return
-- dump(aveh, '?? aveh:'..#aveh)
-- local vehData = core_vehicle_manager.getVehicleData(aveh[1])
local ioCtx = vehData.ioCtx
dump(ioCtx.preloadedDirs, '?? pre_DIRS:')
if true then return end
local playerVehicle = vehManager.getPlayerVehicleData()
-- dump(playerVehicle.vdata.nodes[#playerVehicle.vdata.nodes],'??==================== vehDATA_node:'..#playerVehicle.vdata.nodes,nil)
-- dump(playerVehicle.vdata.triangles[1],'??==================== vehDATA_trng:'..tostring(#playerVehicle.vdata.triangles),nil)
-- dump(playerVehicle.vdata.nodes[#playerVehicle.vdata.nodes],'??==================== vehDATA_node:'..#playerVehicle.vdata.nodes,nil)
-- dump(playerVehicle.vdata.triangles[1],'??==================== vehDATA_trng:'..tostring(#playerVehicle.vdata.triangles),nil)
-- dump(playerVehicle.vdata.beams[1],'??==================== vehDATA_beam:'..tostring(#playerVehicle.vdata.beams),nil)
-- dump(playerVehicle.vdata.triangles[1],'??==================== vehDATA_trng:'..tostring(#playerVehicle.vdata.triangles),nil)
-- dump(playerVehicle.vdata.beams[1],'??==================== vehDATA_beam:'..tostring(#playerVehicle.vdata.beams),nil)
-- dump(playerVehicle.vdata.components,'??==== vehDATA:',nil,2)
-- dump(playerVehicle.vdata.beams[1],'??==================== vehDATA_beam:'..tostring(#playerVehicle.vdata.beams),nil)
-- dump(playerVehicle.vdata.components,'??==== vehDATA:',nil,2)
local am,dbeam = M.vehFrom(playerVehicle.vdata)
for k,v in pairs(dbeam) do
-- dump(v,'??==================== vehDATA_dbeam:'..tableSize(dbeam),nil)
break
-- playerVehicle.vdata.components
-- dump(playerVehicle.vdata.nodes,'?? vehDATA:',nil,1)
local id = obj:getID()
-- dump(amesh[1].data,'??______________ for_m:'..tostring(amesh[1]),nil,2)
-- local anode = editor.getNodes(obj)
-- lo('?? added:'..i..':'..#avp..' AF:'..#afp..'/'..tableSize(af)..':'..(endIndex-startIndex))
-- dump(afp,'?? AFP:')
-- dump(afp,'?? AFP:')
-- dump(afp,'?? AFP:')
-- dump(afp,'?? AFP:')
--[[
-- lo('?? FAFFFFPPPP:'..tableSize(bag)..':'..tostring(am[1].faces))
-- dump(bag, '?? FAFFFFPPPP:'..tableSize(bag))
else
lo('?? bufs:'..#av..':'..#an..':'..#auv..':'..#af..':'..lastMeshInfo.uv1Count..':'..#am)
dump(auv[1], tostring(av[1])..':'..tostring(an[1]))
dump(af[1], '?? faces1:')
dump(auv[1], tostring(av[1])..':'..tostring(an[1]))
dump(af[1], '?? faces1:')
dump(af[2], '?? faces2:')
dump(af[1], '?? faces1:')
dump(af[2], '?? faces2:')
dump(af[3], '?? faces3:')
dump(af[2], '?? faces2:')
dump(af[3], '?? faces3:')
]]
table.remove(astep,#astep)
-- dump(astep,'?? if_ASTEP:')
U.map(astep,function(k,v)
fin.close()
-- dump(afav, '?? afav:')
end
-- local amat = scenetree.findClassObjects('Material')
-- dump(dmat, '?? DMAT:')
lo('<< up:'..tostring(cdae))
local adir = FS:directoryList(path..'/', false, true)
-- dump(adir,'>> dir2list:'..path..':'..tostring(#adir)..':'..#afav)
local out,outf = {},{}
end
-- dump(out, '?? out:')
table.sort(out,function(a,b)
-- file list
-- dump(out, '?? dir2list:')
local list = FS:findFiles(path..'/', '*.dae', 0, false, false)
local function toColor(mat, a, keep)
-- dump(a, '?? alphaSet:')
-- if not mat then return end
-- daedata.djoint = {}
-- dump(daedata.dgeo, '?? DGEO:'..val..':'..n..':'..tableSize(daedata.dgeo),nil,2)
for k,d in pairs(daedata.dgeo) do
c = {c.x,c.y,c.z,alpha}
-- dump(b.av, '?? for_NODE:'..i)
U.out.agraph[#U.out.agraph+1] = {
if not val or d.key == val then
-- dump(beamdata.abeam, '?? for_GRAPH:',nil,2)
-- dump(d.list, '?? for_GRAPH2:')
-- dump(beamdata.abeam, '?? for_GRAPH:',nil,2)
-- dump(d.list, '?? for_GRAPH2:')
local aplain,ahl,ahlb = {},{},{}
-- lo('>> groupExtract:'..tostring(gkey)..':'..tostring(#beamdata.abeampick))
-- dump(abeampick, '>> groupExtract:'..tostring(beamdata.agpick[1].key))
local ahl,aplain,go,abm = groupExtract(gkey, abeampick)
local atkn = U.split(s, '"', true)
-- dump(atkn, '?? token:'..i..' gn:'..groupn)
local stamp = U.stamp({atkn[2],atkn[4]})
local stamp = U.stamp({atkn[2],atkn[4]})
-- dump(dfrom[groupn], '?? if_DEL:'..i..':'..groupn..':'..stamp)
-- if true then break end
local atkn = U.split(s, '"', true)
-- dump(atkn, '?? token:'..i..' gn:'..groupn)
local stamp = U.stamp({atkn[2],atkn[4]})
local stamp = U.stamp({atkn[2],atkn[4]})
-- dump(dfrom[groupn], '?? if_DEL:'..i..':'..groupn..':'..stamp)
-- if true then break end
table.sort(adel)
dump(adel, '?? to_DEL:')
local linemove = {}
})
dump(d,'?? for_stamp:'..k..':'..stamp)
break
table.remove(astep,#astep)
-- dump(astep,'?? if_ASTEP:')
U.map(astep,function(k,v)
fin.close()
-- dump(afav, '?? afav:')
end
end
dump(beamdata.abeampick, '?? group_edit:')
local ain,iins = beamDel(beamdata.abeampick,aline)
end
dump(dextparam,'?? values_EXT:')
-- cleanup params
end
dump(dextparam,'?? values_EXT_clean:')
-- dump(beamdata.agroup, '?? agroup:', nil, 2)
dump(dextparam,'?? values_EXT_clean:')
-- dump(beamdata.agroup, '?? agroup:', nil, 2)
local oval = {
end
dump(oval,'?? values_OVAL:')
-- for k,v in pairs(oval) do
local grp = beamdata.agpick[1]
-- dump(beamdata.cpart,'?? BP_part:'..#beamdata.abeampick,nil,2)
local keyto = grp.key
end
dump(dfrom, '?? DFROM:'..beamdata.cpart.file)
local aline = {}
local atkn = U.split(s, '"', true)
-- dump(atkn, '?? token:'..i..' gn:'..groupn)
local stamp = U.stamp({atkn[2],atkn[4]})
local stamp = U.stamp({atkn[2],atkn[4]})
-- dump(dfrom[groupn], '?? if_DEL:'..i..':'..groupn..':'..stamp)
-- if true then break end
table.sort(adel)
dump(adel, '?? to_DEL:'..keyto)
local linemove = {}
-- local cg = beamdata.agpick[1].key
-- dump(beamdata.agpick, '?? AGPICK:'..cg)
W.onVal('group_in', keyto)
W.onVal('group_in', keyto)
-- dump(beamdata.agpick, '?? AGPICK_POST:'..cg)
W.onVal('beams_up')
-- dump(ajpart, '?? AJPART:',nil,2)
--[[
end
-- dump(aveh, '?? aVEH:')
for i,id in pairs(aveh) do
end
dump(beamdata.agpick, '?? AGPICK_POST2:'..cg)
]]
-- if not tonumber(val) then return end
-- dump(beamdata.agpick[1].list[val],'?? BP:'..beamdata.agpick[1].key..':'..val,nil,2)
beamdata.abeampick[#beamdata.abeampick+1] = val -- beamdata.agpick[1].list[val]
beamdata.abeampick[#beamdata.abeampick+1] = val -- beamdata.agpick[1].list[val]
-- dump(val, '?? abpick:',nil, 2)
partRender()
end)
-- dump(abeampick, '?? abpSEL:')
local ahl,aplain,go,abm = groupExtract(beamdata.agpick[1].key, abeampick)
end) or {}
-- dump(beamdata.cbeams, '?? cbeams:'..#beamdata.cbeams,nil,2)
if not U.index(cbeams,val)[1] then
]]
-- dump(val, '?? bo1:')
-- dump(beamdata.cgroup, '?? bo_gr:')
-- dump(val, '?? bo1:')
-- dump(beamdata.cgroup, '?? bo_gr:')
--[[
-- local ma = beamdata.dbeam[beamdata.cpart.name].ma
-- dump(ma, '?? for_MA:')
partRender()
end
dump(part.amesh,'?? jpick:'..val..':'..tostring(unsel))
ageopin = {}
env.ui['cbeam'] = nil
-- dump(name2ind, '?? n2i:')
W.partPin()
-- lo('?? ageopin:'..#ageopin)
-- dump(ageopin, '?? ageopin:')
-- trigger repaint
lo('?? dae_OUT:'..env.ui['lod_up'])
-- dump(amesh[env.ui['lod_up']].data,'?? dae_OUT:',nil,1)
M.toDAE(amesh[env.ui['lod_up']].data, '/tmp/test_save.dae')
if not geo then return end
-- dump(apiece,'?? part_pick:'..val..':'..#apiece..'/'..#geo.fbag)
local m = geo.m
lo('?? fBAG:'..#fbag)
-- dump(daedata.djoint, '?? dJOINT:')
local pos = amesh[env.ui['lod_up']].body:getPosition()
end),w=0.01}
dump(U.out.aset[1], '?? aset:')
for i,p in pairs(apiece) do
dump(geo.fbag[p],'?? piece:'..p)
for _,fi in pairs(geo.fbag[p]) do
for _,fi in pairs(geo.fbag[p]) do
dump(fi, '?? fbag_SRC:'..p)
-- af[m.af[]
for i,d in pairs(apiece) do
-- dump(geo.abag[d], '?? bag:')
for _,ind in pairs(geo.abag[d]) do
local om = amesh[env.ui['lod_up']].body
-- dump(amesh[env.ui['lod_up']].data,'?? if_DATA:'..tostring(amesh[env.ui['lod_up']].data),nil,1)
om:createMesh({})
-- lo('?? fBAG:'..#fbag)
-- dump(daedata.djoint, '?? dJOINT:')
-- get joints
end
dump(aline, '?? aline:'..tableSize(U.out.agraph))
local apth = {}
end
-- dump(apiece, '?? aPIECE:')
--[[
local geo = daedata.dgeo[env.ui['geo_up']]
-- dump(geo.fbag[val], '?? for_PIECE:'..val)
local m = geo.m
env.ui[key] = val
-- dump(amesh[1],'?? for_MESH:',nil,2)
-- dump(daedata.alod[1],'?? for_LOD:',nil,2)
-- dump(amesh[1],'?? for_MESH:',nil,2)
-- dump(daedata.alod[1],'?? for_LOD:',nil,2)
elseif key == 'model_on' then
end
dump(aveh, '?? aVEH:')
for i,id in pairs(aveh) do
local pos = amesh[1].body:getPosition()
-- dump(fbag[val], '?? part_over:'..tostring(val)..':'..tostring(m))
U.out.aset[1] = {set=U.map(fbag[val].av,function(k,v)
end
-- dump(bag4surf[val[1]][val[2]],'?? '..val[1]..':'..val[2]..':'..tostring(#m.faces))
local flist = bag4surf[val[1]][val[2]]
end
-- dump(av, '?? for_TRI:')
U.out.aset[1] = {set=av, c={1,1,0}, w=0.002}
elseif key == 'mat_on' then
-- dump(daedata.dgeo,'?? mat_on:'..amat[val+1]..':'..tostring(cgeo),nil,2)
-- if true then return end
local mat = daedata.dgeo[m.key].mat
-- dump(mat.c,'?? for_DS:'..i..':'..ds..':'..tostring(m.key)..':'..tostring(mat.c)) --..(#am - 1)..':'..(i-(#am - 1)/2-1)) --..':'..ds)
-- colorOn(mat.body,{mat.c[1],mat.c[2],mat.c[3],0.5+0.5*math.abs(val/10)})
U.union(abeam, d.abeam)
-- dump(daedata.dgeo[d.key].abeam, '?? ABEAM:')
end
end
dump(abeam,'?? for_AGP:'..#abeam,nil,2)
]]
lo('?? if_CROSSlist:'..#list)
-- dump('?? list:'..#list..':'..#abeam)
elseif p1 then
]]
-- dump(d.abeam, '?? ABEAM2:'..i)
-- U.out.aset[1] = {set=po}
-- U.out.aset[1] = {set=po}
-- dump(U.out.agraph[1], '?? for_BEAMS:'..#U.out.agraph)
-- _conf.camSpeed = core_camera.getSpeed()
if k == nm then
-- dump(d.abeam, '?? if_AO:', nil, 2)
aobeam = d.abeam
end
-- dump(aobeam, '?? if_PIN:'..daedata.dgeo[key].name)
U.out.agraph = {}
-- if beamdata.dbeam and not beamdata.dbeam[partname] then
-- dump(beamdata.dbeam, '?? for_DBEAM:'..partname,nil,2)
-- end
end
-- dump(beamdata.dbeam,'?? DMEAN:'..tostring(partname)..':'..#aobeam,nil,2)
if not beamdata.dbeam[partname] then
dump(beamdata.dbeam,'!! NO_PARTBEAMS:'..tostring(partname),nil,2)
return
end
-- dump(beamdata.dbeam,'?? part_name:'..tostring(aobeam)..':'..tostring(partname)..':'..tostring(nm)..':'..tostring(key),nil,2)
local abeam = beamdata.dbeam[partname].list
-- local abeam = M.forBeams(aobeam,beamdata.anode)[partname].list
-- dump(abeam, '?? ABEAM:',nil,1)
--[[
if #U.index({'rb8r_rb8rr','b3ll_rf1l'},b.stamp) > 0 then
dump(b,'?? for_ST:'..i..':'..b.stamp,nil,1)
list[#list+1] = b
local cfr,cto = vec3(0,0.5,0.5),vec3(0,0,1)
-- dump(beamdata.anode[1], '?? node:')
if abeam then
c = {c.x,c.y,c.z,alpha}
-- dump(b.av, '?? for_NODE:'..i)
U.out.agraph[#U.out.agraph+1] = {
daedata.dgeo[d.key].abeam = forBeams(ageopin[1])
dump(daedata.dgeo[d.key].abeam, '?? if_AB:',nil, 2)
-- if not daedata.dgeo[d.name].abeam then
-- {av={i1,i2},deform,strength,spring}
-- dump(daedata.dgeo[d.key].abeam,'?? for_ABEAM:')
-- dump(d.abeam, '?? for_ABEAM:'..#d.abeam..':'..#daedata.dgeo[d.key].abeam)
-- dump(daedata.dgeo[d.key].abeam,'?? for_ABEAM:')
-- dump(d.abeam, '?? for_ABEAM:'..#d.abeam..':'..#daedata.dgeo[d.key].abeam)
--[[
end
-- dump(d.abeam, '?? ABEAM2:'..i)
-- U.out.aset[1] = {set=po}
-- U.out.aset[1] = {set=po}
-- dump(U.out.agraph[1], '?? for_BEAMS:'..#U.out.agraph)
_conf.camSpeed = core_camera.getSpeed()
local astick = {}
-- dump(daedata.dgeo,'??****************** TO_ANIM:'..val,nil,2)
danim['for_joints'] = {cb=forJoints, N=tableSize(daedata.dgeo),
local dense = U.density(astick)
-- dump(djoint,'?? geopin:'..#ageopin..':'..dense..':'..#astick,nil,1)
if dense > 0.04 then dense = 0.04 end
-- if true then return end
-- dump(daedata.dgeo[val], '??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ geo_up:'..val)
-- dump(ageopin, '?? geo_up_PRE:')
-- dump(daedata.dgeo[val], '??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ geo_up:'..val)
-- dump(ageopin, '?? geo_up_PRE:')
lo('?? geo_up:'..val..'/'..#U.index(ageopin,val))
-- geonode.astep[#geonode.astep+1] = val
-- dump(geonode.astep, '?? GAS:')
geonode.apart = {}
-- geonode.path = {daedata.dgeo[val].name}
-- dump(ageopin, '?? geo_up_POST:')
beamdata.m = daedata.dgeo[val].m
-- dump(ageopin, '?? geo_up:'..val)
env.ui['geo_drag'] = daedata.dgeo[val].pos
inwait = 0
-- dump(daedata.dgeo,'??****************** TO_ANIM:'..val,nil,2)
local astick = {}
local dense = U.density(astick)
-- dump(djoint,'?? geopin:'..#ageopin..':'..dense..':'..#astick,nil,1)
if dense > 0.04 then dense = 0.04 end
-- show joints
-- dump(astick, '?? ASTICK:')
local dense = U.density(astick)
end
-- dump(geonode,'?? abag:'..tableSize(djoint)..':'..#astick)
-- lo('??****************** FROM_ANIM:')
-- dump(daedata.dgeo[val], '?? for_GEO:',nil, 2)
-- dump(fbag,'?? BB:'..#abag..':'..#fbag)
-- dump(daedata.dgeo[val], '?? for_GEO:',nil, 2)
-- dump(fbag,'?? BB:'..#abag..':'..#fbag)
if true then return true end
-- parse to plates
-- dump(daedata.dgeo[val], '?? for_M:')
fbag = M.forPlate(daedata.dgeo[val].m) -- {list=,av=,sel=}
local joint,lst = M.forJoint(fbag,daedata.dgeo[val].m)
dump(joint, '?? JOINT:'..(lst and #lst or 'none'))
--[[
]]
-- dump(U.out.aset[1], '??********************* SET:')
-- fbag = U.map(fbag,function(k,v)
-- end)
-- dump(fbag, '?? geo_up_FBAG:')
-- lo('?? geo_up:'..#fbag)
if m.key == cgeo then
-- dump(m.faces,'?? WHOLE:')
idel = i
end
-- dump(am[idel].faces, '?? ifFF:')
-- dump(fbag,'?? FBAG:')
-- dump(am[idel].faces, '?? ifFF:')
-- dump(fbag,'?? FBAG:')
-- bags to meshes
local af = {}
-- dump(pm[#pm].faces, '?? list:'..i)
for j,f in pairs(flist.list) do
end
-- dump(bag4surf,'?? b4s:'..tostring(bag4surf))
-- lo('?? geo_up:'..tostring(cgeo))
-- W.out.cmesh = pos
-- dump(daedata.alod[val], '?? lod_up:'..val,nil,3)
U.out.agraph = {}
for k,v in pairs(daedata.alod[val].list) do
-- dump(v.mat, '?? for_MAT2:'..v.mat.body)
dgeo[#dgeo+1] = {key=k, m=v.m,
daedata.ageo = dgeo
-- dump(dgeo, '?? for+DGEO:'..tostring(dgeo[1].mat.body..''),nil,3)
--[[
})
dump(d,'?? for_stamp:'..k..':'..stamp)
break
W.jpartSort(ajpart, 4, 2)
-- dump(ajpart, '?? dae_in_SORTED:',nil,2)
-- table.sort(ajpart,function(a,b)
end
dump(po, '?? PO_rad:')
U.out.aset[1] = {set=U.map(po,function(k,v)
local alod = M.daeFrom(cpath)
dump(alod[1], '?? if_LOD:'..tostring(#alod), nil, 2)
-- if true then return end
-- if true then return end
-- dump(dlod,'?? for_DLOD:',nil,2)
-- local alod = {}
-- build LOD meshes
-- dump(d.list, '?? dgeo_list:'..k..':'..d.name..':'..#d.list, nil, 2)
if true then
end
-- dump(am[1],'?? if_VALID:'..k..':'..tostring(M.valid(am))..' s:'..s..' h:'..h)
if M.valid(am) then
-- if k==2 then
-- dump(am, '?? forPOS:'..k..':'..s..':'..#am)
-- end
end
-- dump(dgeo, '?? DGEO:',nil,1)
daedata.dgeo = dgeo -- ordered by key
end
-- dump(daedata.ageo,'?? AGEO:',nil,2)
table.sort(daedata.ageo,function(a,b)
local dbeam = M.forBeams(pvd.vdata.beams)
-- dump(dbeam['pickup_radiator'], '?? DBEAM:')
dump(pvd.vdata.nodes[1], '?? NODES_1:')
-- dump(dbeam['pickup_radiator'], '?? DBEAM:')
dump(pvd.vdata.nodes[1], '?? NODES_1:')
for k,v in pairs(dbeam) do
-- if k == 'pickup_radiator' then
-- dump(d.abeam, '?? abeam:'.._)
-- end
end
dump(po, '?? PO_rad:')
U.out.aset[1] = {set=U.map(po,function(k,v)
-- beamdata.pos = (mi+ma)/2 --+ be:getObjectByID(pvd.id):getPosition()
-- dump(dgeo,'?? for_DGEO:',nil,2)
-- dump(dgeo, '?? DGEO:')
am = {}
end
dump(aveh, '?? aVEH:')
for i,id in pairs(aveh) do
end
dump(aveh, '?? aVEH:')
for i,id in pairs(aveh) do
-- lo('?? mat1:'..tostring(scenetree.findObject(amn[1]).obj))
dump(amn, '?? mat_LIST:')
-- dump(om:getMaterialNames(),'?? if_OM:'..tostring(om:getMeshMaterialNames()))
dump(amn, '?? mat_LIST:')
-- dump(om:getMaterialNames(),'?? if_OM:'..tostring(om:getMeshMaterialNames()))
-- dump(om:getMeshMaterialNames(), '?? mnm:')
-- dump(om:getMaterialNames(),'?? if_OM:'..tostring(om:getMeshMaterialNames()))
-- dump(om:getMeshMaterialNames(), '?? mnm:')
-- dump(om, '?? for_DAE:'..tostring(om.obj),nil, 2) --..':'..om.__parent)
-- dump(om:getMeshMaterialNames(), '?? mnm:')
-- dump(om, '?? for_DAE:'..tostring(om.obj),nil, 2) --..':'..om.__parent)
end
local dgeo = M.daeFrom(p)
-- dump(dgeo, '?? DGEO:')
-- daedata.dgeo = dgeo
local pos = vec3(0,0,2) --amesh[1].body:getPosition()
dump(d.m.faces,'??^^^^^^^^^^^^ 155:'..#d.m.verts)
U.out.aset[1] = {set=U.map(d.m.verts,function(k,v)
-- indae = true
-- dump(fsnode.afile, '?? cfile:'..tostring(fsnode.cfile)..':'..val)
elseif key == 'fav_up' then
local fout = io.open('/save/exp/favdir.json', "w")
dump(fsnode.adir, '?? afav0:'..fsnode.path..':'..tostring(val))
local pth = fsnode.path..fsnode.adir[val].s
end
-- dump(fsnode.adir, '?? afav:'..pth) --..fsnode.path..':'..tostring(val))
dump(afav, '?? afav:'..fsnode.path..':'..tostring(#ind))
-- dump(fsnode.adir, '?? afav:'..pth) --..fsnode.path..':'..tostring(val))
dump(afav, '?? afav:'..fsnode.path..':'..tostring(#ind))
U.toFile({list=afav,last=cpath}, {'save','exp'}, 'favdir.json')
lo('?? dir_up:'..path)
-- dump(fsnode.astep, '?? astep_pre:'..ind[1])
-- fsnode.astep = {fsnode.astep[1]}
-- fsnode.astep = {fsnode.astep[1]}
-- dump(fsnode.astep, '?? astep:'..ind[1]..':'..#fsnode.astep..':'..tableSize(fsnode.astep))
fsnode.adir,fsnode.afile = W.dir2list(path)
fsnode.adir,fsnode.afile = W.dir2list(path)
dump(fsnode.afile,'?? dir_up:')
-- lo('<< dir_up:'..path..':'..#fsnode.adir)
end
-- dump(fsnode, '?? fsnode:')
end
-- close group
-- dump(beamdata.agpick, '?? agpick:',nil,2)
-- dump(beamdata.abeampick, '?? aBpick:',nil,2)
-- dump(beamdata.agpick, '?? agpick:',nil,2)
-- dump(beamdata.abeampick, '?? aBpick:',nil,2)
for j=#beamdata.abeampick,1,-1 do
avail = im.GetContentRegionAvail()
-- dump(beamdata.agpick[1],'?? cgroup:',nil,2)
local grp = beamdata.agpick[1]
elseif not onjpart or U.index(ageopin,d.key)[1] then
-- dump(ageopin,'?? solid:'..d.key..':'..c..':'..d.name..':'..tostring(inhover))
-- solid color
-- origonal color
-- dump(d.mat.c, '?? color_BACK:'..tostring(env.ui['geo_on'])..':'..tostring(inhover))
editor.setMaterialProperty(d.mat.body, 'translucent', 0, "1")
editor.setMaterialProperty(d.mat.body, 'translucent', 0, "1")
-- dump(d.mat,'?? if_MAT:'..c)
M.colorOn(d.mat.body,d.mat.c)
end
-- dump(geonode.astep, '?? forGAS:'..tostring(inhover)..':'..tostring(env.ui['geo_on']))
if geonode.astep then
end
-- dump(d.mat.c,'?? for_COLOR:'..k..':'..tostring(d.name))
end
end
dump(geonode.astep, '?? forGAS:')
if geonode.astep then
colorOn(d.mat.body,d.mat.c)
-- dump(d.mat.c,'?? for_COLOR:'..k..':'..tostring(d.name))
end
end
dump(geonode.astep, '?? forGAS:')
if geonode.astep then
colorOn(d.mat.body,d.mat.c)
-- dump(d.mat.c,'?? for_COLOR:'..k..':'..tostring(d.name))
end
end
-- dump(beamdata.anode[b.av[1] ],'?? node:')
-- break
if incontrol and incontrol[2] then
-- dump(incontrol, '?? inCONTROL:')
-- env.ui[incontrol[1]] = incontrol[2]
elseif cval['geo_drag'] then
dump(cval['geo_drag'].akey, '?? to_REST:')
dragRestore()
]]
-- dump(mat.c,'?? for_DS:'..i..':'..ds..':'..tostring(m.key)..':'..tostring(mat.c)) --..(#am - 1)..':'..(i-(#am - 1)/2-1)) --..':'..ds)
-- colorOn(mat.body,{mat.c[1],mat.c[2],mat.c[3],0.5+0.5*math.abs(val/10)})
if inbeams == 2 then
-- dump(beamdata.abeam,'?? inbeams:'..tostring(inbeams),nil,2)
end
-- lo('?? ifBEAMS:'..tostring(ageopin[1]))
-- dump(beamdata.dbeam,'?? if_BEAMS:'..tostring(ageopin[1])) --..':'..tostring(beamdata.dbeam[ageopin[1]]))
-- U.out.agraph[1] = {list=forBeams(ageopin[1]), c={1,1,0,0.6}, w=2, z=false}
-- U.out.agraph[1] = {list=forBeams(ageopin[1]), c={1,1,0,0.6}, w=2, z=false}
-- dump(U.out.agraph[1].list, '?? for_BEAMS:')
--[[
if not beamdata.ds then
dump(d.abeam, '?? if_ABEAM:')
-- get beams displacment
cm = cm/#daedata.dgeo[key].m.verts
-- dump(daedata.dgeo[key].m.verts, '?? for_D:'..tostring(cm))
-- dump(d.abeam,'?? for_BM:'..tostring(#d.abeam))
-- dump(daedata.dgeo[key].m.verts, '?? for_D:'..tostring(cm))
-- dump(d.abeam,'?? for_BM:'..tostring(#d.abeam))
local cb = vec3(0,0,0)
-- {av={i1,i2},deform,strength,spring}
-- dump(daedata.dgeo[d.key].abeam,'?? for_ABEAM:')
dump(d.abeam, '?? for_ABEAM:'..#d.abeam..':'..#daedata.dgeo[d.key].abeam)
-- dump(daedata.dgeo[d.key].abeam,'?? for_ABEAM:')
dump(d.abeam, '?? for_ABEAM:'..#d.abeam..':'..#daedata.dgeo[d.key].abeam)
local mis,mas = math.huge,-math.huge
-- U.out.agraph[1] = {list=daedata.dgeo[d.key].abeam, c={1,1,0,0.8}, w=4, z=false}
-- dump(daedata.dgeo[d.key].abeam, '?? if_PATH:'..#daedata.dgeo[d.key].abeam)
if inhover == c then
-- dump(d.mat.c,'?? for_MAT:'..tostring(c)..':'..tostring(#d.m.verts))
editor.setMaterialProperty(d.mat.body, 'translucent', 0, "0")
@/lua/vehicle/controller/esc.lua
--dump(otherWheelOnAxle)
wheelIdCache = {}
@/lua/common/jbeam/materials.lua
--log('D', "material.init", "###########################################################################")
--dump(triggers)
--dumpTableToFile(triggers, false, "triggers.js")
@/lua/ge/extensions/scenario/raceMarkers/cylinderMarker.lua
function C:setMode(mode)
--dump(self.id .. " -> " .. mode)
if mode == 'hidden' then
@/lua/ge/extensions/core/hardwareinfo.lua
--dump(res)
guihooks.trigger('HardwareInfo', res)
@/lua/vehicle/energyStorage.lua
--dump(availableStorageFactories)
--dump(storageFactories)
--dump(energyStorages)
--dump(storageFactories)
--dump(energyStorages)
--dump(beamTriggers)
--dump(breakTriggerBeams)
@/lua/ge/extensions/flowgraph/nodes/gameplay/rally/rallyDebugNode.lua
function C:work(args)
-- dump("yo")
if self.pinIn.vehId.value then
local pinPos = vec3(self.pinIn.pos.value)
-- dump(pinPos)
debugDrawer:drawSphere(pinPos, 0.1, ColorF(0.2, 1.0, 0.2, 0.5), false, false)
@/lua/console/bananabench-xml.lua
}
dump(vehicles)
--dump(res)
writeXML(res, filepath)
@/lua/ge/extensions/editor/gen/world.lua
end
U.dump(daePath[cls])
end
U.dump(daePath[tp], '?? daeLoad_DP:'..tp)
lo('<< daeLoad:'..tp..':'..#afile)
U.dump(aref, '?? for_ext:'..tostring(ext)..':'..L..':'..tableSize(aref))
--++
if dbg then
U.dump(ij, '?? forBuilding2:'..tostring(desc))
end
if scope == 'side' and ij then
-- U.dump(cij, '?? for_IJ:')
if #ij == 0 then ij = cij end
aijside = W.forSide(ij)
-- U.dump(aijside, '?? aijside:')
end
if dbg then
U.dump(desctop.df, '?? fC_done:')
end
end
U.dump(cij, '<< forJSON:')
end
end
-- U.dump(ddae, '??_________________________________ for_DDAE:')
-- U.dump(dpart, '??_________________________________ for_DPART:')
-- U.dump(ddae, '??_________________________________ for_DDAE:')
-- U.dump(dpart, '??_________________________________ for_DPART:')
lo('??^^^^^^^^^^^^^^ mod_CUSTOM:')
-- lo('?? for____PLINTH:')
-- U.dump(aplinth, '?? for____PLINTH:')
end
-- pos.z = desc.pos.z
U.dump(desc.pilaster, '??____*****^^^^^^^^^^^^^^^ for_PILA:'..desc.ij[1]..':'..desc.ij[2]..':'..desc.pilaster.span..' h:'..hfr..'>'..hto..' pos:'..pos.z..':'..tostring(cedit.forestkey))
local ckey = to(desc, desc.pilaster.dae,
if desc[tp].daecorner and isconv > 0 and not out.acorner then
-- U.dump(ddae[desc[tp].daecorner],'?? border.hasCorner:'..desc[tp].daecorner)
-- cornermargin = {desc[tp].daecorner.to.x}
if not descnext[tp].skew then
U.dump(aplinth, '?? if _PPP:'..tostring(base)..':'..tp..':'..tostring(desc[tp].daecorner))
aplinth[#aplinth][2] = (base and base[desc.ij[2]]:distance(U.mod(desc.ij[2]+1,base)) or desc.u:length()) - ddae[desc[tp].daecorner].to.y
end
-- U.dump(descnext[tp], '?? if_NEXT:')
-- lo('??>>>>>> if_CF:'..tostring(cforest)..':'..tostring(cedit.forest))
end
U.dump(aplinth, '??____ APLINTH_:')
for _,p in pairs(aplinth) do
pos + u*p[2], ddae[dae], a)
-- U.dump(list,'??>>>> for_SEGMENT:'..tostring(list and #list or 0))
if list then
if dbg then
U.dump(ax, '?? wU_AX:')
end
if dbg then
U.dump(b1, '?? PS1:')
U.dump(b2, '?? PS2:')
U.dump(b1, '?? PS1:')
U.dump(b2, '?? PS2:')
out.avedit = {}
if dbg then
U.dump(abase[#abase], '?? presSPL:'..n..':'..#abase[#abase])
end
if dbg then
U.dump(b1, '?? split1:')
U.dump(b2, '?? split2:')
U.dump(b1, '?? split1:')
U.dump(b2, '?? split2:')
end
end
if dbg then U.dump(sbase, '?? to_RC:'..#sbase..':'..(sbase[1]-sbase[2]):length()..':'..tostring(isvalid)) end
if isvalid then
end
if not indrag and dbg then U.dump(arc, '<< coverUp: rects='..n..':'..#arc) end
-- use frame for corners
U.dump(desc.acorner_, '?? frame_CORNER:')
for i,c in pairs(desc.acorner_) do
end
U.dump(dfcorner, '?? frame_DFCORNER:')
end
forBuilding(adesc[id], function(w, ij)
-- U.dump(ijmask, '?? mu_ij0:'..scope..':'..ij[1]..':'..ij[2]..':'..tostring(forall))
if not tonumber(ij[2]) then
if cw.pilaster and cw.pilaster.yes then
U.dump(cw.pilaster, '?? has_PIL:'..j..':'..#cw.df[forestMeshName])
for _,key in pairs(cw.df[forestMeshName]) do
if ddae[forestMeshName].type == 'stairs' then
U.dump(ddae[forestMeshName], '?? for_STAIRS:')
local daedata = ddae[forestMeshName]
if cedit and cedit.mesh then
U.dump(cij, '?? markUp.for_TOP0:'..tostring(cedit.mesh))
local floor = adesc[cedit.mesh].afloor[cij[1]]
end
U.dump(ax, '?? AX:')
U.dump(ay, '?? AY:')
U.dump(ax, '?? AX:')
U.dump(ay, '?? AY:')
local function baseSet(nm)
U.dump(out.inedge, '?? baseSet:'..nm)
local floor = adesc[cedit.mesh].afloor[out.inedge[1]]
local body = floor.top.body
U.dump(body, '?? for_v12:'..icc..':'..tostring(v1)..':'..tostring(v2))
if v1:length() > v2:length() then
local plate1 = U.polyMargin(gablePlate(rc1, 1, tip), floor.top.margin, {3})
U.dump(plate1, '??+++++**** PLATE1 istart:'..1)
--- set achild
local plate2 = U.polyMargin(gablePlate(rc, 2, tip), floor.top.margin, {2})
U.dump(plate2, '??+++++**** PLATE2 istart:'..2)
local p1, p2 = closestLinePoints(
local function forSpanY(desc, ij, val)
U.dump(ij, '>> forSpanY:'..tostring(val))
local w = desc.afloor[ij[1]].awall[ij[2]]
-- adjust height according to intersections
U.dump(sbase, '?? pyra_base:')
local idh
if not sdata or #sdata == 0 then
U.dump(sbase, '??_______________ ERR_NO_sdata:')
end
av,auv,af = T.pave(base)
U.dump(av, '?? paved:')
an = {vec3(0,0,1)}
L,dL,dC = ddae[rbdae].to.x - ddae[rbdae].fr.x, 0.6, 0.105
-- U.dump(desctop.av, '?? for_AV:'..tostring(ddae[rbdae].fr)..':'..tostring(ddae[rbdae].to)..':'..L)
end
end
-- U.dump(ddae[rbdae].fr, '?? FR:')
-- U.dump(ddae[rbdae].to, '?? TO:')
-- U.dump(ddae[rbdae].fr, '?? FR:')
-- U.dump(ddae[rbdae].to, '?? TO:')
--========================================
-- end
-- U.dump(desctop.av, '?? forStraight:'..i1..':'..i2..':'..i3)
local u = dsc.av[i2] - dsc.av[i1]
if desc.afloor[#desc.afloor].top.poly == 'V' then
U.dump(desctop, '?? border_FOR_V:')
-- for _,c in pairs(desctop.achild) do
-- U.dump(c, '?? for_child:')
--- plate I
cedit.mesh = toedit
-- U.dump(desc, '?? toedit:')
-- return
f.ij = {i}
-- U.dump(f.awplus, '??_____________________+++++++++++ for_AWP:'..i)
-- if i == 2 then U.dump(f.awplus, '??_____________________+++++++++++ for_AWP:') end
-- U.dump(f.awplus, '??_____________________+++++++++++ for_AWP:'..i)
-- if i == 2 then U.dump(f.awplus, '??_____________________+++++++++++ for_AWP:') end
if not f.awplus then f.awplus = {} end
for k,wp in pairs(f.awplus) do
-- U.dump(wp, '?? for_WP:'..i..':'.._)
if wp.dirty then
lo('?? child_id:'..tostring(c.id)..':'..tostring(c.prn),true)
-- U.dump(c,'?? child_id:'..tostring(c.id)..':'..tostring(c.prn),true)
-- c.prn = f
-- update position
-- U.dump(c.afloor[1].top, '?? child.for_TOP:')
houseUp(c)
local mbody,afpos,base,aforest,invalid = W.splineUp(desc, ij[1], ij[2], s) -- s.id and s.base or nil)
-- U.dump(s, '?? to_SPLINE:'..tostring(mbody)..':'..#s.aforest) --..':'..tostring(mbody))
if M.valid({mbody}) then
lo('??__________^^^^^^^^^^^^^^^^^^^^^ SPLINED:'..#aforest..'/'..#afpos..':'..tostring(invalid))
-- U.dump(cij, '?? CIJ:')
if s.o then
if s.o then
-- U.dump(s, '??******* pre_FCLEAN:')
if not invalid then
-- lo('?? DZ:'..dz)
-- U.dump(aforest, '?? for_F:'..#afpos)
if s.fupdate then
end
-- U.dump(iforest,'??*****____________ if_IFOREST:'..#cedit.aforest..':'..preaf..':'..preceaf)
if #iforest>0 and preceaf>0 then
lo('!!_________________^^^^^^^^^^^^^^ ERR_WRONG_SPLINE:'..k)
-- U.dump(s,'!!_________________^^^^^^^^^^^^^^ ERR_WRONG_SPLINE:'..k)
end
lo('?? post_AF:'..#cedit.aforest)
-- U.dump(desc.aspline, '?? for_SPLINE:'..k..':'..#am..':'..tostring(mbody))
-- am[#am+1] = mbody
if desc.aspline then
-- U.dump(desc.aspline,'??_______________ ASPLINE:'..i)
for ifloor,aw in pairs(desc.aspline) do
if ifloor == i then
-- U.dump(aw,'??****************** for_SPLf:'..ifloor..':'..j)
for kwall,s in pairs(aw) do
w.win = s.aforest[1] and s.aforest[1].dae or w.win
-- U.dump(s.def, '?? for_SDEF:')
goto wallskip
if not w.uvref then
-- U.dump(w.uvref,'?? for_UV_ref:'..i..':'..j)
-- U.dump(w.uvscale,'?? for_UV_scale:'..i..':'..j)
-- U.dump(w.uvref,'?? for_UV_ref:'..i..':'..j)
-- U.dump(w.uvscale,'?? for_UV_scale:'..i..':'..j)
if i > 1 then
w.uvref = {0, forHeight(desc.afloor, i-1)}
-- U.dump(w.uvref,'?? ht:'..forHeight(desc.afloor, i-1))
end
-- lo('?? wallPOS:'..i..':'..j..':'..tostring(w.pos)..':'..tostring(p))
-- U.dump(w, '?? for_WALL:')
-- lo('??********* forWall:'..i..':'..j)
av,af,an,auv,mhole,arcext = wallUp(w, desc, k) --, (i==2 and j==5 and true) or false)
-- U.dump(arcext, '?? if_ARCEXT: wall:'..j..':'..tostring(#arcext))
if arcext and #arcext>0 then
-- if U._PRD == 0 and #arcext>0 then
-- U.dump(arcext,'??**************** rcEXT:'..#arcext)
if i < #desc.afloor then
local base = fe.base
-- U.dump(base, '?? uppder_BASE:')
if not botext then
end
-- U.dump(rc, '?? to_WALL:'..je..':'..k..':'..tostring(U.mod(j+1,f.base) - f.base[j]))
we.arcext[#we.arcext+1] = rc
-- if we.arcext then
-- U.dump(base,'?? for_WEE:'..je..':'..tostring(base[je])..'>'..tostring(base[je+1])..we.ij[1]..':'..we.ij[2]..':'..#we.arcext..':'..tostring(we.u))
-- end
-- U.dump(botext, '?? if_BE:'..j)
if botext then
-- U.dump(botext, '?? for_BOTEXT:')
bote = base2ext(base, botext)
for k,c in pairs(f.top.achild) do
-- U.dump(c, '??^^^^^^^^^^^^^^^^^ for_CEST:'..k)
local botec
if botext[je] then
-- U.dump(botext[je],'??__________+++++++++++++++ be_CHECK:'..k..':'..je..':'..icb)
-- U.dump(c.base, '?? child_BASE:'..tostring(c.base[icb])..':'..tostring(U.mod(icb+1,c.base)))
-- U.dump(botext[je],'??__________+++++++++++++++ be_CHECK:'..k..':'..je..':'..icb)
-- U.dump(c.base, '?? child_BASE:'..tostring(c.base[icb])..':'..tostring(U.mod(icb+1,c.base)))
for ie=1,#botext[je],4 do
end
-- U.dump(botec, '?? for_EXBC:')
c.topext = base2ext(c.base, botec)
c.topext = base2ext(c.base, botec)
-- U.dump(c.topext, '??^^^^^^^^^^^^^------------- for_CTOPEXT:'..i..':'..k)
end
f.topext = bote
-- U.dump(f.topext,'??^^^^^^^^^^^^^^^ hU.topext:'..f.ij[1])
end
end
-- U.dump(bote, '?? for_BOTE:')
end
-- if i==2 and j==5 then
-- U.dump(w, '??********** for_AF:')
-- end
if i==2 and j == 2 then
U.dump(an, '??++++++++++++ for_WALL_an:'..j..':'..tostring(w.pos)..':'..#av..':'..#af)
U.dump(av, '?? av:')
U.dump(an, '??++++++++++++ for_WALL_an:'..j..':'..tostring(w.pos)..':'..#av..':'..#af)
U.dump(av, '?? av:')
U.dump(af, '?? af:')
U.dump(av, '?? av:')
U.dump(af, '?? af:')
U.dump(auv, '?? auv:')
U.dump(af, '?? af:')
U.dump(auv, '?? auv:')
end
]]
-- U.dump(av, '?? for_WALL:'..j..':'..tostring(w.pos))
-- lo('?? postWU:'..#am..':'..#av)
end
-- U.dump(desc, '?? desc:')
-- U.dump(av, '?? av:')
-- U.dump(desc, '?? desc:')
-- U.dump(av, '?? av:')
-- lo('?? postWA2:')
-- if intopchange then
-- U.dump(f.base, '?? CHANGED_BASE:'..j)
-- end
-- if w.ij[1] == 2 and w.ij[2] == 3 and mhole then
-- U.dump(mhole, '?? for_holes:')
-- end
-- lo('??________ pre_CM:'..i..':'..j..':'..#cam..':'..spany)
-- U.dump(cam, '??________ pre_CM:'..i..':'..j..':'..#cam)
if #cam > 0 then
else
U.dump(cam, '!! ERR_houseUp_MESH:'..i..':'..j)
end
else
U.dump(cam, '!!ERR_houseUp_MESH:'..i..':'..j)
end
lo('??^^^^^^^^^^^^^^ hU.RIDGE:'..i..':'..tostring(isvalid)..':'..#f.top.achild..' istart:'..f.top.istart,true)
-- U.dump(f.top.achild, '?? chDATA:')
-- U.dump(f.top.achild[1].ridge.data, '?? chDATA:')
-- U.dump(f.top.achild, '?? chDATA:')
-- U.dump(f.top.achild[1].ridge.data, '?? chDATA:')
if not isvalid then
end
-- U.dump(f.top, '??_________________if_RIDGE:')
-- lo('?? hU_ridge2:'..tostring(f.top.ridge.flat),true)
local function forFat(mdata, base, desctop)
-- U.dump(mdata.verts, '?? forFat.mdata:'..#base..':'..desctop.shape)
-- if true then return end
-- if true then return end
-- U.dump(base, '?? forFat.base:'..#base)
local cbase = {}
end
-- U.dump(cbase, '?? forFat.mbase:')
cbase = U.polyStraighten(cbase)
cbase = U.polyMargin(cbase, desctop.margin)
-- U.dump(cbase, '?? forFat.base:')
if desctop.shape == 'ridge' then
-- U.dump(mdata, '?? fat_RIDGE:',true)
if #base == 4 then
-- uvs = desctop.adata[1].auv,
-- U.dump(mdata, '?? fF_gable:')
asi = {1,2,3,6,5,4}
subdata = deepcopy(mdata)
-- U.dump(asi, '?? ASI1:'..#subdata.verts)
-- upper edge
asi[#asi+1] = asilast
-- U.dump(asi, '?? ASI2:'..#subdata.verts)
-- lift original
end
-- U.dump(subdata, '<< forFat:')
-- U.dump(asi, '<< forFat_ASI:')
-- U.dump(subdata, '<< forFat:')
-- U.dump(asi, '<< forFat_ASI:')
-- asi = nil
if prn then lo('??^^^^^^^^^^ BOT_PRN: floor:'..desc.floor..':'..cij[1]..':'..hprn..':'..#prn.afloor..':'..tostring(cheight),true) end
-- U.dump(f.botext, '??__________ if_BE:'..i)
local av,af,auv = polyPave(f.botext or f.base,
end
-- U.dump(mdatabot.verts, '??^^^^^^^^^^^^^^^^^^^^ hU.paved_bot:'..#f.top.achild)
if forsplit or ((ischild or dirty) and dsc.id == nil) then
-- U.dump(adata,'?? r1:',true)
-- lo('?? r1:',true)
-- if forsplit then-- or dsc.id == nil then
-- U.dump(adata,'?? mesh_NEW:'..lbl)
-- create
-- if dsc.ridge.on then
-- U.dump(adata,'?? r2_data:'..tostring(dsc.id)..':'..tostring(dsc.shape)..':'..tostring(obj)..':'..tostring(dsc.ridge),true)
-- end
lo('?? for_CHILD:'..ic..':'..tostring(c.shape)..':'..tostring(c.fat))
-- U.dump(c, '?? for_CHILD:'..ic)
c = f.top.achild[ic]
lo('??+++++++++++++++++++++++ for_child_ridge:'..ic..':'..tostring(c.shape)..' fat:'..tostring(c.fat),true)
-- U.dump(f.top.achild[1].ridge.data,'??+++++++++++++++++++++++ for_child_ridge:'..ic)
-- T.forRidge(f, c.base, ic)
-- local c = f.top.achild[ic]
-- U.dump(c.base, '?? pre_rup:'..i..':'..ic..':'..tostring(c.id)..':'..tostring(forsplit)..':'..tostring(dirty)..':'..tostring(c.shape), true)
-- lo('??^^^^^^^^^^ hU_pre_rU:'..c.shape..':'..c.istart,true)
mdata = amdata and amdata[1] or nil
-- U.dump(mdata, '?? hU_post_rU:'..tostring(mdata)..':'..tostring(c.shape),true)
-- if c.shape == 'gable' then
-- if c.shape == 'gable' then
-- U.dump(c,'?? for_TOP_child:'..ic..':'..tostring(c.shape)..':'..tostring(c.adata and #c.adata or nil),true)
-- end
end
-- U.dump(subdata, '??^^^^^^^^^^^^^ SUBDATA:'..tostring(c.id)..':'..tostring(forsplit))
end
-- if U._PRD == 0 and c.shape == 'gable' then
-- U.dump(desctop.adata, '?? for_child_Gable:'..#desctop.adata..':'..c.shape..':'..tostring(desctop.id..':'..tostring(dirty)))
-- desctop.id = nil
toRender(c, am, 'lid', true)
-- U.dump(c, '??_______________ for_CHILD:'..ic..':'..tostring(c.shape)..':'..tostring(c.fat)..':'..tostring(mdata))
elseif mdata then
-- lo('?? preRender:'..ic..':'..c.shape..':'..tostring(subdata and tableSize(subdata) or nil)..':'..tostring(data and tableSize(data) or nil))
-- U.dump(data, '?? preRender_d:'..ic..':'..tostring(data and tableSize(data) or nil))
-- lo('??^^^^^^^^^^^^^^^^^^^^^^^^ pre_TORENDER:')
-- toRender(c, data, 'lid', true)
-- U.dump(c, '?? post_render0:'..ic..':'..tostring(c.id),true)
-- U.dump(f.top.achild, '?? post_render:'..ic..':'..tostring(c.id),true)
-- U.dump(c, '?? post_render0:'..ic..':'..tostring(c.id),true)
-- U.dump(f.top.achild, '?? post_render:'..ic..':'..tostring(c.id),true)
-- if #f.top.achild == 0 then
-- U.dump(f.top.achild, '?? post_render101:'..i)
if not f.top.shape then f.top.shape = 'flat' end
-- U.dump(f.base, '?? hU_base:'..i)
local amdata = roofUp(f.top.shape, desc, i, nil, prn)
local amdata = roofUp(f.top.shape, desc, i, nil, prn)
-- U.dump(amdata,'?? hU.post_rU:'..#amdata)
mdata = amdata and amdata[1] or nil
-- if true and desctop.shape ~= 'gable' and i == #desc.afloor and desctop.fat and desctop.fat>0 then
-- U.dump(mdata, '?? to_FAT:')
local asi
if f.top.shape == 'gable' then
-- U.dump(f.top.adata, '?? adata:')
amd = {}
end
-- U.dump(asi, '??+++++++++++++++++++++++++++++++++++++ if_AMD:'..#amd..':'..#asubdata)
-- U.dump(subdata, '?? subdata:')
-- U.dump(asi, '??+++++++++++++++++++++++++++++++++++++ if_AMD:'..#amd..':'..#asubdata)
-- U.dump(subdata, '?? subdata:')
if f.top.shape == 'gable' then
local af = deepcopy(desctop.adata[k].af)
-- U.dump(af, '?? for_AF:'..k..':'..#af)
for k = 1,#af,3 do
end
-- U.dump(desctop.adata[1].af, '??++++++++++++++++++++++++++++++++++++ if_SUBD:'..#asubdata..':'..#desctop.adata[1].af..':'..#am..':'..#desctop.adata)
-- U.dump(am, '?? preR:'..#am,true)
-- U.dump(desctop.adata[1].af, '??++++++++++++++++++++++++++++++++++++ if_SUBD:'..#asubdata..':'..#desctop.adata[1].af..':'..#am..':'..#desctop.adata)
-- U.dump(am, '?? preR:'..#am,true)
toRender(desctop, am, 'lid')
-- lo('??______________________________________ pre_RENDER:'..#data..':'..#mdatabot.verts) --..tostring(data[2].material)..':'..tostring(tmat)..':'..tostring(tmat.doubleSided)) --..tostring(defmat.doubleSided)..':'..tostring(defmat.obj))
-- U.dump(data, '?? pre_RENDER:'..tostring(defmat.doubleSided),nil,2)
toRender(desctop, data, 'lid')
-- f.top.id = nil
-- U.dump(mdata, '??______________ for_FLOOR_pre:'..i)
end
end
-- U.dump(f.top.achild, '?? post_render10:'..i)
-- U.dump(desc.afloor[2].achild, '?? post_render111:')
-- U.dump(f.top.achild, '?? post_render10:'..i)
-- U.dump(desc.afloor[2].achild, '?? post_render111:')
lo('??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ hU_border:'..i)
-- U.dump(f.top.border,'??____________ for_BORDER:'..tostring(#f.top.border.shape)..':'..tostring(f.top.shape), true)
-- if dbg then
-- U.dump(afb, '?? toBAM.AFACE:'..#afb)
-- U.dump(avert, '?? toBAM.AVERT:')
-- U.dump(afb, '?? toBAM.AFACE:'..#afb)
-- U.dump(avert, '?? toBAM.AVERT:')
-- U.dump(iseq, '?? iseq:')
-- U.dump(avert, '?? toBAM.AVERT:')
-- U.dump(iseq, '?? iseq:')
-- U.dump(auvb, '?? toBAM.auvb:')
-- U.dump(iseq, '?? iseq:')
-- U.dump(auvb, '?? toBAM.auvb:')
-- end
f.top.ij = {i}
-- U.dump(f.top.achild, '?? post_render11:'..i)
else
-- U.dump(f.top.achild, '?? post_render22:'..i)
-----------------------------
-- U.dump(f.awplus,'??+++++++++++++++++ av_PLUS:'..i..':'..#f.awplus)
-- U.dump(f.awplus, '?? av_PLUS:'..i..':'..forHeight(desc.afloor, f.ij[1])..':'..f.h)
-- U.dump(f.awplus,'??+++++++++++++++++ av_PLUS:'..i..':'..#f.awplus)
-- U.dump(f.awplus, '?? av_PLUS:'..i..':'..forHeight(desc.afloor, f.ij[1])..':'..f.h)
local uvv
local uvv
-- U.dump(f.awplus,'?? hU_prePLUS:'..tableSize(f.awplus))
-- U.dump(f.awplus,'??++++++++++++ for_SUBROOF:'..i)
-- U.dump(f.awplus,'?? hU_prePLUS:'..tableSize(f.awplus))
-- U.dump(f.awplus,'??++++++++++++ for_SUBROOF:'..i)
for k,wp in pairs(f.awplus) do
if wp.list then
-- U.dump(wp.list, '?? for_AWP:'..i..':'..tostring(dirty))
for _,list in pairs(wp.list) do
for _,list in pairs(wp.list) do
-- U.dump(list,'??++++++++++++++++ for_WP:')
for key,p in pairs(list) do
uvv = -forHeight(desc.afloor, f.ij[1])*(f.awall[list.ind].uvscale and f.awall[list.ind].uvscale[2] or 1)
-- U.dump(list, '?? for_list:'.._..':'..tostring(list[1])..':'..tostring(uvv))
)
-- U.dump(list, '??^^^^^^^^^^^^^^^^ subroof_AN:'..k..':'.._..':'..#an..':'..tostring(an[1]))
-- an = {f.awall[list.ind].u:cross(f.awall[list.ind].v)}
local scale = (desc.afloor[list[i][1]].h-0.001)/mlen
-- U.dump(list, '?? for_ac_list:'..i)
local u = desc.afloor[list[i][1]].awall[list[i][2]].u
local ang = U.vang(u, vec3(1,0,0), true)+math.pi/2
-- U.dump(list[i],'?? toCorner.in_STEM:'..i..tostring(base2world(desc, list[i]))..':'..list[i].dae)
-- lo('??+++++ toC:'..i)
local function stem2corner(dae, ij, tot, mlen)
-- U.dump(ij, '>> stem2corner:'..tot..':'..tostring(dae))
-- local nmesh = round(tot/mlen)
if desc.acorner_ then
-- U.dump(desc.acorner_, '??>>>>>> for_CORNER:'..tableSize(desc.acorner_))
for i,s in pairs(desc.acorner_) do
if s and #s.list>0 then
-- U.dump(s.list[1], '?? for_AC:'..i..':'..tostring(s.list)..':'..s.list[1]['1'])
-- get stem
-- get stem
-- U.dump(s.list[1],'??^^^^^^^^^^^^^^^^^^^^^^^^^^^^ for_corner:'..tostring(s.list[1]['1']),true)
local tot,ci,istart,scale = desc.afloor[s.list[1][1]].h,2,1
while ci <= #s.list do
-- U.dump(s.list, '??+++ while_STEM:'..i..':'..ci,true)
-- lo('?? in_STEM:'..i..':'..ci..':'..tostring(s.list[ci][1] - s.list[ci-1][1]))
-- tot = tot + desc.afloor[s.list[ci-1][1]].h
-- U.dump(s.list[istart], '?? for_STEM:'..i..':'..ci..'/'..istart..':'..tostring(tot),true)
-- stem2corner(s.list[istart].dae, s.list[istart], tot, mlen)
end
-- U.dump(desc.df, '??<<<<<< for_CORNER:'..tableSize(desc.acorner_))
-- if i > 1 then break end
lo('!! ERR_MESH_QE:', true)
-- U.dump(am, '!! mesh:'..#am)
end
lo('??----------- houseUp.NEW:'..#am)
-- U.dump(am, '??----------- houseUp.NEW:')
local newid, om
end
-- U.dump(desc.afloor[2].top.achild, '?? post_render333:') --..ic..':'..tostring(c.id),true)
if out.editkey then
-- lo('?? HU3:'..':'..tostring(cedit.forest))
-- U.dump(out.avedit, '<< houseUp:')
end
end
-- U.dump(wdesc.uvref,'??^^^^^^^^^^^^^^^^^ for_SCALE:'..wdesc.u:length()..':'..wdesc.ij[2],true)
if not wdesc.uvref then wdesc.uvref = {0,0} end
lo('?? fj1:'..tostring(desc.pos)..':'..tostring(desc.id))
-- U.dump(desc.pos, '?? fj1:'..tostring(desc.pos))
houseUp(desc)
lo('?? for_shape:'..tostring(W.ui.building_shape))
-- U.dump(W.ui.mat_wall, '??___________ GEN_mat:')
if W.ui.building_style == 0 then
end
-- U.dump(awmat, '?? mats:')
end
-- U.dump(dmat.roof, '?? mats_ROOF:'..tostring(mat))
mat = tostring(mat)
end
-- U.dump(awall, '?? awall:')
-- afloor[#afloor + 1] = {base = base, h = h, awall = awall}
-- afloor[#afloor].top.shape = 'gable'
-- U.dump(afloor[1].awall[1], '?? for_MAT:')
-- render
-- for key,b in pairs(adesc) do
-- U.dump(adesc[key].afloor[1].base, '<< buildingGen:'..key..':'..tostring(adesc[key].pos))
-- end
-- end
-- U.dump(adesc[1].afloor[1].base, '<< buildingGen:')
-- lo('<<'..cedit.mesh)
-- lo('<<'..cedit.mesh)
-- U.dump(adesc[cedit.mesh].afloor[1].base, '<< buildingGen:'..tostring(adesc[cedit.mesh].pos))
end
arc[#arc+1] = {fr={cx/xma,(1-img.size.y/yma)}, to={(cx+img.size.x)/xma,1}}
-- U.dump(arc[#arc],'?? for_rc:'..apth[i]..':'..xma)
-- arc[apth[i]] = {fr={cx/xma,(1-img.size.y/yma)}, to={(cx+img.size.x)/xma,1}}
end
-- U.dump(mesh, '?? for_MESH_top:')
lo('?? for_DM:'..tostring(cedit.cval['DragMat'])..':'..tostring(isrel),true)
if isrel then
-- U.dump(cedit.cval['DragMat'], '?? uv_ROOF:'..tostring(ds)..':'..tostring(floor.top.achild))
local n = 1
c.uvref = {cedit.cval['DragMat'][n][1][1]+ds.x, cedit.cval['DragMat'][n][1][2]+ds.y}
-- U.dump(c, '??______________ for_lid:')
n = n+1
end)
-- U.dump(floor.top, '??^^^^^^^^^^^^^^^^^^^^ mM:')
else
w.uv[4] = suv[n][4] - ds:dot(v)
-- U.dump(w.agrid, '?? for_AGRID:')
for _,xy in pairs(w.agrid) do
-- lo('?? for_XY1:'..tostring(xy[1])..':'..tostring(xy[2]), true)
-- U.dump(xy[1], '?? for_XY1:')
-- U.dump(xy[2], '?? for_XY2:')
-- U.dump(xy[1], '?? for_XY1:')
-- U.dump(xy[2], '?? for_XY2:')
auv = M.uv4grid({w.uv[1], w.uv[3]}, {w.uv[2], w.uv[4]},
-- U.dump(mesh.uvs, '?? for_UV:'..#mesh.verts..':'..#mesh.uvs)
-- auv = {}
-- lo('?? u'..tostring(w.u),true)
-- U.dump(w.agrid, '?? AGRID:')
--[[
local n = 1
-- U.dump(cedit.cval['DragMat'], '?? DM:')
W.forRoof(floor.top, function(c)
c.uvscale = {cedit.cval['DragMat'][n][2][1]*scale[1], cedit.cval['DragMat'][n][2][2]*scale[2]}
-- U.dump(c.uvscale,'?? matScale:'..n..':'..scale[1]..':'..scale[2])
n = n+1
local n = 1
-- U.dump(cedit.cval['DragMat'], '?? matScale:'..tostring(scale[1])..':'..tostring(scale[2]))
if scope == 'top' then
w.uvscale = {cedit.cval['DragMat'][n][1]*scale[1],cedit.cval['DragMat'][n][2]*scale[2]}
U.dump(w.uvscale,'?? for_scale:'..ij[1]..':'..ij[2])
n = n+1
-- lo('>> matMove:'..tostring(v)..':'..idobj)
-- U.dump(aedit[idobj].desc, '?? desc:')
-- U.dump(aedit[idobj].mesh, '?? mesh:')
-- U.dump(aedit[idobj].desc, '?? desc:')
-- U.dump(aedit[idobj].mesh, '?? mesh:')
if aedit[idobj] == nil then
if #cedit.cval == 0 then
-- U.dump(desc, '?? reNEW:'..idobj)
-- TODO: for roof
mesh.uvs = auv
-- U.dump(auv, '?? AUV:'..#auv..':'..#desc.agrid..':'..#desc.agrid[1][1])
-- mesh.uvs = M.uv4grid({desc.uv[1], desc.uv[3]}, {desc.uv[2], desc.uv[4]}, desc.ax, desc.ay)
end)
-- U.dump(acorner, '<< cornersBuild_:')
return acorner
local function meshApply(tp, ind) -- ind is 0-based
-- U.dump(dforest[cedit.forest], '?? cfor')
if ind+1 > #daePath[tp] then
-- dae = daePath[tp][ind]
-- U.dump(out.inhole.achild, '?? achild:'..tostring(tp)..':'..child.body..':'..dae)
child.body = dae
dae = daePath[tp][ind+1]
-- U.dump(cij, '?? meshApply:'..tp..':'..ind..':'..tostring(cedit.forest-1)..':'..tostring(dae))
desc = adesc[cedit.mesh]
-- desc = adesc[cedit.mesh]
-- U.dump(desc.acorner,'?? for_CORNER:'..tostring(desc.df)..':'..tostring(cedit.forest))
-- lo('?? ifforr11:'..tostring(iforest))
-- desc.acorner = cornersBuild(desc, ind)
-- U.dump(desc.df, '?? if_F:')
-- forestClean(desc, true)
forBuilding(adesc[cedit.mesh], function(w, ij)
-- U.dump(w.df, '?? for wall:'..ij[1]..':'..ij[2]..':'..cedit.forest)
-- U.dump(w.df, '??_+__ DF:'..cedit.forest..':'..tostring(cedit.forest == w.df[dae]))
-- U.dump(w.df, '?? for wall:'..ij[1]..':'..ij[2]..':'..cedit.forest)
-- U.dump(w.df, '??_+__ DF:'..cedit.forest..':'..tostring(cedit.forest == w.df[dae]))
if iforest then return end
if forspline then
-- U.dump(forspline.aforest, '?? for_SPLINE:'..cedit.forest..':'..cedit.fscope..':'..tp)
for i,d in pairs(forspline.aforest) do
if tp == 'storefront' then
-- U.dump(w, '?? for_SF:'..tostring(cedit.forest)..':'..tostring(tp),true)
local daepre = U.forOrig(dforest[cedit.forest].item:getData():getShapeFile())
w.storefront.len = w.storefront.len - ddae[daepre].len + ddae[dae].len
-- U.dump(cedit.forest, '?? for_SF:')
-- local dae = w[tp].adae
elseif ({win=1,door=1})[tp] then
-- U.dump(w.df,'?? mA_wd:'..ij[1]..':'..ij[2]..':'..tostring(cedit.fscope)..':'..tostring(cedit.mesh))
-- else
w[tp] = dae -- daePath[tp][ind]
-- U.dump(w[tp..'_inf'], '?? ddae:')
if tp == 'win' and ddae[w[tp]] then w.winbot = ddae[w[tp]].fr.z end
-- adjust basement height
-- U.dump(w.doorstairs[w.doorind],'?? for_stairs:'..tostring(w.doorstairs[w.doorind]))
adesc[cedit.mesh].afloor[1].h = math.abs(ddae[w.doorstairs[w.doorind].dae].fr.z) + ddae[dae].fr.z
end
-- U.dump(ddae[dae], '??^^^^^^^^^^^^^^^^ meshApply2:'..tp..':'..tostring(dae))
if dae then
else
U.dump(w, '!! NO_DAE_FOR_WALL:'..tp)
end
end
-- U.dump(ddae[w[tp]], '??___________ meshApply:'..w[tp])
-- w.update = true
houseUp(adesc[cedit.mesh], cedit.mesh, true)
-- U.dump(adesc[cedit.mesh].afloor[cij[1]].awall[cij[2]].df,'?? after_HU:'..tostring(cedit.forest)..' ifor:'..iforest)
-- lo('?? iff333:'..tostring(iforest)..':'..tostring(tp))
if not cij[2] then cij[2] = 1 end
-- U.dump(cij, '??___^^^**** if_MESH:'..tostring(cedit.mesh))
if adesc[cedit.mesh].afloor[cij[1]].awall[cij[2]].df[dae] then
-- toJSON(adesc[cedit.mesh])
-- U.dump(adesc[cedit.mesh].df, '?? for_DF:')
-- lo('<< meshApply:'..ind..':'..tostring(cedit.forest)..':'..tostring(out.inhole)..':'..tostring(W.ifForest()), true) -- tostring(dforest[cedit.forest].item))
local desc = adesc[cedit.mesh]
-- U.dump(desc.aspline, '?? if_SEL:'..tostring(desc.selection and tableSize(desc.selection) or nil))
if desc and desc.selection then
end
-- U.dump(dmesh[cmesh].sel, '?? matApply_for_mesh:'..tostring(#dmesh[cmesh].sel))
return
-- wo:createMesh({{{}}})
-- U.dump(desc.afloor[2].awall[2],'?? DONE:')
-- U.dump(info, '?? for_INF:'..tostring(info))
-- U.dump(desc.afloor[2].awall[2],'?? DONE:')
-- U.dump(info, '?? for_INF:'..tostring(info))
-- lo(''..tostring(currentMaterial:getField("normalMap", 0)))
-- lo(''..tostring(currentMaterial:getField("normalMap", 0)))
-- U.dump(currentMaterial.normalMap, '?? for_NM:')
-- local fields = currentMaterial:getFields()
-- local normalMapObj = out.imUtils.texObj(currentMaterial:getNormalMap())
-- dump(currentMaterial)
-- U.dump(currentMaterial, '?? NMO"')
-- dump(currentMaterial)
-- U.dump(currentMaterial, '?? NMO"')
currentMaterial.activeLayers = 1
end
-- U.dump(desc.selection, '?? if_SEL:')
end
imat = U.index(dmat.roof, dae)[1]
-- U.dump(dmat.roof, '?? mroof:'..tostring(dae)..':'..tostring(imat))
end
dae = adesc[cedit.mesh].afloor[cij[1]].awall[cij[2]].mat
-- U.dump(dmat.wall, '?? mat_wall:'..dae)
imat = U.index(dmat.wall, dae)[1]
dae = adesc[cedit.mesh].afloor[cij[1]].awall[1].mat
-- U.dump(dmat.wall, '?? mat_floor:'..dae)
imat = U.index(dmat.wall, dae)[1]
end
-- U.dump(cij, '?? sO:'..tostring(dae)..':'..tostring(scope)..':'..tostring(imat))
-- out.curselect = daeIndex('door', dae)
lo('<< scopeOn:'..tostring(out.curselect)..':'..tostring(cedit.forest)..':'..tostring(cedit.fscope))
-- U.dump(aedit[cpart].desc.ij, '?? scopeOn_ij:')
end
end
U.dump(dsc.df[dae].skip,'?? for_skip:') --..dforest[cedit.forest].item:getData():getShapeFile())
--[[
for _,key in
U.dump(dforest[cedit.forest], '?? for_key:')
local desc = adesc[dforest[cedit.forest].mesh]
cij = U.clone(aedit[id].desc.ij)
U.dump(cij, '>> partOn:'..tostring(id)..':'..tostring(aedit[id]))
-- lo('>> partOn:'..tostring(id)..' i:'..tostring(cij[1]))
-- U.dump(aedit[id].desc, '?? DESC:')
if aedit[id].desc.type == 'top' and scope ~= 'top' then
return cij
-- U.dump(aedit[id], '>> partOn:'..id)
end
-- scenetree.findObject('edit'):deleteAllObjects()
-- U.dump(dforest, '?? forestEdit:'..tostring(key))
local meshid = dforest[key] and dforest[key].mesh or nil
end
-- U.dump(dforest[key], '?? for_mesh:')
local desc = adesc[meshid]
end)
U.dump(cij, '<< forestEdit:'..key)
end
local floor = adesc[cedit.mesh].afloor[cij[1]]
U.dump(aint,'>>__________****** topSplit:'..cij[1]..':'..#aint)--..':'..floor.stop.mat)
if #aint == 0 then return end
base = c.base
-- U.dump(floor.top.achild, '?? for_ACHILD:'..tostring(floor.top.cchild)..':'..tostring(#floor.top.achild))
mat = c.mat
tip = tip/2
-- U.dump(base, '?? for_base:'..#base)
local achunk,amap = U.polyCut(base, aint[1], aint[2])
local achunk,amap = U.polyCut(base, aint[1], aint[2])
-- U.dump(achunk, '?? for_CHUNKS:'..#achunk)
-- U.dump(amap, '?? for_MAP:'..#amap)
-- U.dump(achunk, '?? for_CHUNKS:'..#achunk)
-- U.dump(amap, '?? for_MAP:'..#amap)
if achunk then
lo('??******************************************************** POST_split:'..floor.top.cchild..'/'..#floor.top.achild..':'..tostring(fat))
-- U.dump(floor.top.achild, '??************************************************************* achild:'..#floor.top.achild)
-- if true then return end
-- W.ui.dbg = true
-- U.dump(floor.top.achild, '?? ACHILD:'..#floor.top.achild)
--!! houseUp(adesc[cedit.mesh], cedit.mesh)
end
U.dump(avclose, '?? CLOSE:'..tostring(cvHit1)..':'..tostring(cvHit2))
-- lo('?? jcut:'..tostring(jcut))
lo('?? for_cut:'..#cut)
-- U.dump(cut, '?? CUT:'..#cut)
-- if true then return end
if #cut ~= 2 then
U.dump(cut,'!! ERR_CUT:'..#cut)
return
end
U.dump(b1, '?? B1:'..#b1..':'..jb..'>'..je)
U.dump(aside1, '?? B1_aside:'..#b1..':'..jb..'>'..je)
U.dump(b1, '?? B1:'..#b1..':'..jb..'>'..je)
U.dump(aside1, '?? B1_aside:'..#b1..':'..jb..'>'..je)
end
U.dump(aside2, '?? B2_aside:'..#b2..':'..#b1..':'..jb..'>'..je)
floor.top.body = {}
floor.update = true
U.dump(floor.top.achild, '?? ACHILD:'..#floor.top.achild)
desc.acorner_ = cornersBuild(desc)
-- U.dump(desc.acorner_, '?? wallCollapse_corner:'..tostring(redraw))
end
-- table.insert(f.base, cij[2] + 1, p)
-- U.dump(f.base, '??******** wallSplit.base:'..cij[2]..':'..(cij[2] % slen + 1))
-- rebuild walls
if cij == nil or cij[1] == nil then return end
U.dump(out.asplit, '>> wallSplit:'..scope..':'..tostring(out.wsplit)) --..':'..cij[1]..':'..cij[2]..':'..tostring(cedit.part))
U.dump(adesc[cedit.mesh].afloor[cij[1]].base)
U.dump(out.asplit, '>> wallSplit:'..scope..':'..tostring(out.wsplit)) --..':'..cij[1]..':'..cij[2]..':'..tostring(cedit.part))
U.dump(adesc[cedit.mesh].afloor[cij[1]].base)
if not out.asplit then return end
for i,e in pairs(out.asplit) do
U.dump(e, '?? u:'..i..':'..e.u..':'..tostring(base2world(adesc[cedit.mesh], e.ij)))
local w = floor.awall[e.ij[2]]
local t,u,v = ray2rect(base2world(adesc[cedit.mesh], e.ij), w.u, w.v, getCameraMouseRay())
-- U.dump({u*w.u:normalized(),v*w.v:normalized()},'?? u_v:'..tostring(u)..':'..tostring(v))
w.achild[#w.achild+1] = {ij = e.ij, rc = {{0,0},{1,v*w.v:normalized()}}}
w.achild[#w.achild+1] = {ij = e.ij, rc = {{0,v*w.v:normalized()},{1,1}}}
U.dump(w.achild, '?? wS.achild:'..i)
end
end
U.dump(floor.base, '?? NEW_BASE:')
end
-- U.dump(desc.acorner_, '?? corner_POST_SPLIT:')
houseUp(nil, cedit.mesh)
if not cij then return end
U.dump(cij, '?? forKey:'..#its)
if #its > 0 then
else
U.dump(cij, '!! NO_F_KEY:')
end
local base = desc.afloor[ij[1]].base
U.dump(ij, '?? wallHit:'..tostring(desc.afloor[ij[1]].base[ij[2]])..':'..tostring(desc.pos)..':'..tostring(desc.afloor[ij[1]].pos)..':')
local d = intersectsRay_Plane(ray.pos, ray.dir,
-- lo('>> ray2rc:'..i..':'..tostring(ray.dir)..':'..#floor.top.achild)
-- U.dump(desctop.base,'??^^^^^^^^^^^^^^^^^^^^^ ifHit:'..tostring(desctop.shape)..':'..tostring(phit)..':'..tostring(p))
for k,c in pairs(floor.top.achild) do
end
-- U.dump(cbase, '?? base_PRE:')
local h = cbase[1].z
-- local arc = coverUp(cbase,cbase[1].z)
-- U.dump(cbase, '?? base_POST:')
-- local arc = coverUp(U.clone(cbase))
local inrc = U.inRC(phit, arc)
-- U.dump(arc,'??^^^^^^^^^^^^^^^^^^^^^ r2r:'..k..':'..tostring(phit)..':'..tostring(inrc))
-- local inrc = U.inRC(phit, {cbase})
-- local inrc = U.inRC(phit, {cbase})
-- U.dump(cbase,'?? inrc:'..k..':'..tostring(inrc))--..':'..tostring(desctop.shape))
if inrc then
lo('?? forRoofHit1:'..tostring(h)..':'..tostring(d)..':'..tostring(p)) --..':'..#floor.top.body)
-- U.dump(lastFloor.top.body, '?? mup.floors:'..#adesc[cedit.mesh].afloor..':'..tostring(p))
if not floor.top then return nil end
-- lo('?? forRoofHit2:'..tostring(inrc))
-- U.dump(floor.top.body, '?? forRoofHit2:'..tostring(inrc)..':'..tostring(d1)..':'..tostring(d2))
local id, ichild = floor.top.id, nil
local id, ichild = floor.top.id, nil
-- U.dump(floor.top.body,'?? forRoofHit.pre_child:'..#floor.top.achild..' inrc:'..tostring(inrc), true)
ichild = W.ray2rc(ray, floor)
if house.selection then
U.dump(house.selection, '??******* CLONE SELECTION:')
local afloor = {}
local function floorAppend()
U.dump(cedit.cval, '>> floorAppend:'..cij[1]..':'..tostring(intopchange))
-- if true then return end
desc.afloor[#desc.afloor + 1] = newFloor
U.dump(newFloor, '?? floorAppend:')
U.dump(newFloor.top, '?? floorAppend_top:')
U.dump(newFloor, '?? floorAppend:')
U.dump(newFloor.top, '?? floorAppend_top:')
uvOn()
houseUp(adesc[cedit.mesh], cedit.mesh)
U.dump(cij, '<< floorAppend:')
end
local function forHit(ray, desc)
-- U.dump(cij, '>> forHit:')
if not desc then return end
-- tops
-- U.dump(f.top, '?? for_mesh:'..i..' af:'..#f.top.af..' av:'..#f.top.av)
if f.top then -- and f.top.af then -- maybe nil if having children
if f.top then -- and f.top.af then -- maybe nil if having children
-- U.dump(f, '!! ERR_forHit:'..i)
local function ifHit(desctop,base)
-- U.dump(ijmi,'>> ifHit:'..i..':'..tostring(base),true)
if base then
local phit = U.ray2plane(ray,p,vec3(0,0,1))
-- U.dump(desctop.base,'??^^^^^^^^^^^^^^^^^^^^^ ifHit:'..tostring(desctop.shape)..':'..tostring(phit)..':'..tostring(p))
local cbase = {}
local inrc = U.inRC(phit, {cbase})
-- U.dump(cbase,'?? ifHit.inrc:'..i..':'..tostring(p)..':'..tostring(inrc)..':'..tostring(desctop.shape)..':'..i..':'..tostring(base2world(desc,{i,1},base[1])))
if inrc then
if inrc then
-- U.dump(cbase,'?? inRC:'..i..':'..tostring(phit))
dmi = (ray.pos-phit):length()
for _,c in pairs(f.top.achild) do
-- U.dump(c.base,'?? forHit_child:'..i..':'..tostring(c.shape)..':'.._)
ifHit(c,c.base)
ifHit(c,c.base)
-- U.dump(ijmi,'??^^^^ if_hit_ch:'..i)
-- lo('?? if_child_af:'..tostring(#c.af)..':'..tostring(ijmi),true)
for j,wp in pairs(f.awplus) do
-- U.dump(wp, '?? for_WP:'..i..':'..j)
for k,r in pairs(wp.list) do
end
-- U.dump(ijmi,'??************ forHit_prewall:'..i..':'..dmi)
-- walls
ijmi = {i,j}
-- U.dump(ijmi,'?? wHIT:'..i..':'..j)
end
if hitwplus and ijmi then ijmi[3] = hitwplus end
-- U.dump(ijmi,'<< forHit:')
return ijmi
local function mdown(rayCast, inject)
U.dump(cij, '>> mdown:')
smouse = rayCast.pos
-- local ray = getCameraMouseRay()
-- U.dump(daePath['win'], '?? IF_DAE2:')
-- local hit = getRayCastHit(getCameraMouseRay(), true)
-- if scope == nil then scope = 'building' end
U.dump(cij, '>>----------- mdown:'..tostring(rayCast.object.name)..'/'..tostring(cameraMouseRayCast(true).object.name)..':'..tostring(scope)..':'..tostring(cij ~= nil and cij[1] or nil)..':'..tostring(cedit.mesh)..':'..tostring(rayCast.pos)..':'..tostring(#editor.getAllRoads())) --..':'..tostring(ray.pos)..':'..tostring(ray.dir)) --..':'..tostring(hit))
-- cmesh = nil
local key = forKey(rayCast)
U.dump(cij, '?? for_cij0:'..tostring(key)) --..':'..tostring(dforest[key].mesh)..':'..scenetree.findObjectById(dforest[key].mesh).name)
if not cij and not cedit.mesh then
lo('?? f_TYPE:'..tp..':'..tostring(desc)..' key:'..tostring(key)..':'..tostring(dforest[key].mesh)..':'..tostring(cedit.mesh))
-- U.dump(cij, '?? for_fc:'..tostring(ind)..':'..tp..'<')
-- cedit.forest = key
end
-- U.dump(desc, '?? for_wall:'..desc[tp])
if not desc.df then desc.df = {} end
-- lo('?? if_cij:'..tostring(cij)..':'..tostring(dforest[cedit.forest].item:getData():getShapeFile()))
U.dump(cij, '?? for_cij:'..dforest[cedit.forest].type)
markUp(U.forOrig(dforest[cedit.forest].item:getData():getShapeFile()))
-- W.houseUp(adesc[cedit.mesh], cedit.mesh)
-- U.dump(dforest, '?? dforest:')
return cedit.mesh
-- if editor.keyModifiers.shift then
U.dump(cij, '?? for_split:'..scope)
if scope == 'top' then
-- WALL SPLIT
-- U.dump(aedit[id].desc.ij,'?? for_ws:'..cij[1]..':'..cij[2])
-- lo('?? for_alt:'..tostring(aedit[id]))
-- local id,inrc = rayCast.object:getID()
U.dump(cij,'?? hit_id:'..tostring(id)..':'..tostring(scope)..':'..tostring(rayCast.object.name)..'/'..nm)
local desc = (id and adesc[id]) and adesc[id] or adesc[cedit.mesh] --or adesc[id]
lo('??+++++ CENTER:'..tostring(ccenter))
-- U.dump(adesc[id].afloor[2].awall[1].ij, '?? PRE_split:')
houseUp(nil, id)
houseUp(nil, id)
-- U.dump(adesc[cedit.mesh].afloor[2].awall[1].ij, '?? POST_split:')
-- select part
rayCast = cameraMouseRayCast(true)
-- U.dump(cij, '?? RH4:')
lo('?? DESC:'..tostring(desc))
elseif string.find(nm, 'o_lid_') ~= 1 then
-- U.dump(desc.afloor[#desc.afloor].top, '?? PRE_roof:'..tostring(cij[1])..':'..tostring(nm))
local roofid,inrc,ichild = forRoofHit(desc,cij[1])
cedit.part = id
U.dump(cij, '?? if_cij1:')
partOn(id)
end
U.dump(cij, '?? if_cij2:')
end
-- U.dump(dtranssel, '?? DTS:')
]]
]]
-- U.dump(dtrans, '?? dtrans:')
local amesh = {}
-- M.copy(dpopsel, dmesh[meshID].sel, dmesh[meshID].buf, 's_magenta')
-- U.dump(dpop, '?? dpop:')
-- dpop->
-- lo('?? mdrag:'..tostring(ds)..':'..tostring(cedit.forest)..':'..tostring(dforest[cedit.forest].item:getScale()))
-- U.dump(dforest, '?? mdrag.dforest:')
-- if editor.keyModifiers.shift then
local mesh = aedit[id].mesh
U.dump(mesh.verts,'?? for_mesh:'..#mesh.verts)
out.inhole = nil
out.inhole = nil
-- U.dump(adesc[cedit.mesh], '?? drag_hole:'..tostring(smouse)..':'..adesc[cedit.mesh].id)
-- lo('?? drag_hole:'..tostring(smouse)..':'..adesc[cedit.mesh].afloor[cij[1]].awall[cij[2]].id)
local desc = adesc[cedit.mesh]
-- U.dump(desc.selection, '?? sel:'..tableSize(desc.selection))
if U._HERE and desc.selection and tableSize(desc.selection) == 1 then
local s = desc.aspline[i][key]
-- U.dump(s, '?? for_SPLINE:'..key)
if s.base then
end
-- U.dump(cedit.cval['DragPos'].dend,'?? if_base:'..iw..':'..tostring(isave))
if iw then
end
-- U.dump(desc.aspline,'?? for_SPLINE:'..key)
-- update building
local desc = adesc[cedit.mesh]
-- U.dump(desc.selection, '?? fdrag:'..tostring(cij[2]))
forBuilding(desc, function(w,ij)
-- ds = vec3(0,-0.2)
-- U.dump(desc.aspline[ij[1]][ij[2]].aforest, '?? AF:')
cedit.cval['DragPos'].cpos = p
lo('??******************* fof:'..tostring(ds))
-- U.dump(d,'?? fof:'..tostring(cedit.cval['DragPos'].s))
d.p = cedit.cval['DragPos'].fpos + ds
-- lo('?? for_CORNER_move:'..tostring(cij[1])..':'..tostring(cij[2]), true)
-- U.dump(out.acorner, '?? acorner:')
-- if true then return end
-- if true then return end
-- U.dump(desc.afloor[cij[1]].base, '?? BASE:')
local ray = getCameraMouseRay()
cedit.cval['DragPos'] = {pos = t}
U.dump(pair,'??+++++++++++++++++++++++++++++ DRAG_freehand:'..tostring(ij[1])..':'..tostring(ij[2])..':'..#out.acorner..':'..tostring(incorner and #incorner or nil)..':'..tostring(pairend)..':'..tostring(scope), true)
-- _dbdrag = true
-- pair,ind,map = W.ifPairHit({incorner[1].ij[1],U.mod(incorner[1].ij[2]-1,#floor.base)})
-- U.dump(pair, '?? PH:'..tostring(ind)..':'..tostring(map))
if editor.keyModifiers.ctrl then
end
U.dump(incorner, '?? incorner:'..scope..':'..cij[2]..':'..tostring(inalong))
-- _dbdrag = true
if imi then
-- U.dump(incorner,'??^^^^^^^^^^^^^^^^^ for_IMI:'..imi..':'..tostring(base[imi])..':'..#incorner..' perp:'..tostring(v))
local x,y = U.lineCross(base[ind],base[ind]+v, base[imi],U.mod(imi+1,base))
--- split opposite side
-- U.dump(base,'?? if_SPLIT:'..imi..':'..#base)
W.floorSplit(floor,imi,v-base[1]) --,floor.top.ridge and floor.top.ridge.on)
-- _dbdrag = true
-- U.dump(base,'?? if_SPLIT_post:'..imi..':'..#base)
end
cedit.cval['DragPos'].insplit = insplit
U.dump(insplit,'?? is_insplit:')
scenetree.findObject('edit'):deleteAllObjects()
pair,ind,map = W.ifPairHit({incorner[1].ij[1],U.mod(ind-1,#base)})
-- U.dump(pair,'?? if_split:'..ind)
-- U.dump(map,'?? map:'..ind)
-- U.dump(pair,'?? if_split:'..ind)
-- U.dump(map,'?? map:'..ind)
-- pairend,pair = W.ifPairEnd({incorner[1].ij[1],U.mod(ind-1,#base)},true)
if pair then
U.dump(pair,'?? if_split:'..ind)
U.dump(map,'?? map:'..ind)
U.dump(pair,'?? if_split:'..ind)
U.dump(map,'?? map:'..ind)
U.dump(pair,'??^^^^^^^^^^^^^^^^ V_drag:'..tostring(ang)..':'..tostring(v)..':'..tostring(u1))
U.dump(map,'?? map:'..ind)
U.dump(pair,'??^^^^^^^^^^^^^^^^ V_drag:'..tostring(ang)..':'..tostring(v)..':'..tostring(u1))
if floor.top.achild then
-- U.dump(floor.top.achild, '?? achild:')
for i,c in pairs(floor.top.achild) do
local t = ray.pos + d*ray.dir
-- U.dump(incorner, '??^^^^^^^^^^^^^^^^^^^^^ for_corners:'..#incorner)
-- _dbdrag = true
-- lo('?? for_db:'..tostring(db), true)
-- U.dump(out.acorner, '??++++++++++++++ for_acorner:')
-- _dbdrag = true
end
-- U.dump(cedit.cval['DragPos'].insplit, '?? for_SPLIT:'..tostring(pairend)..':'..tostring(editor.keyModifiers.ctrl))
if editor.keyModifiers.ctrl then
if editor.keyModifiers.ctrl then
-- U.dump(cedit.cval['DragPos'].insplit,'?? if_SPLIT:'..tostring(pairend))
-- if pairend then
if cedit.cval['DragPos'].insplit then
-- U.dump(cedit.cval['DragPos'].insplit, '??^^^^^^^^^^^^^^^^^^^^^ for_VVVV:'..#incorner)
-- _dbdrag = true
local base = desc.afloor[s.floor].base
-- U.dump(base,'?? for_base:')
local u1,u2 = U.mod(s.fr,base) - U.mod(s.fr-1,base), U.mod(s.fr,base) - U.mod(s.fr+1,base)
end
-- U.dump(desc.afloor[2].base, '?? new_BASE:')
houseUp(desc, cedit.mesh, true)
local desc = adesc[cedit.mesh]
-- U.dump(desc.selection,'?? drag_free:'..tostring(desc)..':'..tostring(desc.selection)..':'..tableSize(desc.selection))
if desc and desc.selection and scope=='wall' and tableSize(desc.selection)==1 then
end
U.dump(cij, '?? move_SIDE:')
local shift = U.proj2D(rayCast.pos - smouse)
local side = forSide()
U.dump(side, '?? SIDE:'..tostring(cij))
for i,f in pairs(side) do
-- lo('?? sel:'..#dmesh[cmesh].sel[1].faces)
-- U.dump(dmesh[cmesh].sel[1].faces, '?? sel:')
inCube(cmesh, frame)
lo('?? drag_CTRL_0:',true)
-- U.dump(desc.afloor[cij[1]].base, '??+++++++ ROTATE:'..tostring(incorner)..':'..tostring(cedit.mesh)..':'..tostring(ccenter)..':'..tostring(adesc[cedit.mesh])..':'..tostring(desc.afloor[2].ij)..':'..scope..' cij:'..tostring(cij[1])..':'..tostring(cij[2]))
-- _dbdrag = true
local pairend,pair,imap = W.ifPairEnd() --nil,true)
-- U.dump(incorner, '?? if_PAIR:'..tostring(pairend)..':'..tostring(incorner))
-- lo('?? if_corner:'..tostring(pairend),true)
-- lo('?? if_corner:'..tostring(pairend),true)
-- U.dump(incorner, '??_________ PE:'..tostring(pairend))
if pairend then
local cbase = desc.afloor[cij[1]].base
U.dump(pair, '?? drag_ctrl_for_pairend:')
cedit.cval['DragRot'].dir = (U.mod(imap[pair[1]]+1,cbase)-U.mod(imap[pair[1]],cbase)):normalized()
-- cedit.cval['DragRot'].dir = (U.mod(pair[1]+1,cbase)-U.mod(pair[1],cbase)):normalized()
-- U.dump(incorner, '?? if_PE0:'..tostring(pairend)..' dir:'..tostring(cedit.cval['DragRot'].dir),true)
--[[
local d = intersectsRay_Plane(ray.pos, ray.dir, p, vn)
U.dump(wall, '?? for_wall:'..tostring(p)..' d:'..tostring(d))
cedit.cval['DragRot'].smouse = ray.pos + d*ray.dir
if c.imap then
-- U.dump(c.imap, '?? for_c_map:'..ij[2])
for k,m in pairs(c.imap) do
end
-- U.dump(desc.afloor[ij[1]].top.achild[1], '?? child_POST:')
--[[
-- elseif pe == 1 and incorner then
U.dump(incorner,'??^^^^^^^^^^^^^^^^^ PE_1:'..tostring(dpos)..':'..tostring(isperp)..' ifit:'..pe,true)
-- _dbdrag = true
if c.imap then
-- U.dump(c.imap, '?? for_c_map:'..ij[2])
for k,m in pairs(c.imap) do
-- elseif incorner then
-- U.dump(incorner, '?? drag_for_V:'..tostring(incorner))
elseif false and U._PRD == 0 then
end
-- U.dump(cedit, '?? mdrag.cedit:')
end
local function select(desc, ij)
U.dump(ij, '>> select:')
if not desc.selection then desc.selection = {} end
-- out.selection = desc.selection
U.dump(desc.selection, '<< select:')
end
-- indrag = false
-- U.dump(cij, '>> forStick:'..tostring(cedit.mesh)..':'..tostring(cedit.part)..':'..tostring(scope))
local function vert2edge(a, base)
if not floor then
U.dump(desc.afloor, '!! NO_FLOOR:')
return
lo('>> mup:'..tostring(W.ui.injunction)..':'..tostring(out.inroad)..':'..tostring(indrag)..' cfor:'..tostring(cedit.forest)..' afor:'..tostring(#cedit.aforest))
-- U.dump(adesc[cedit.mesh].selection, '??+++++++++++++++++ mup.if_SELECTION:')
end
-- U.dump(cedit.cval['DragVal'], '?? mup.control:')
incontrol = false
ds = forNear(sfloor.base,tfloor.base,sfloor.pos+desc.pos,tfloor.pos)
U.dump(tfloor.base,'?? ds:'..tostring(ds)..':'..tostring(sfloor.pos)..':'..tostring(tfloor.pos)..':'..tostring(desc.pos))
elseif scope == 'floor' then
if indrag then
U.dump(cij, '>> mup_post_DRAG:'..tostring(cedit.cval['DragPos']))
if U._PRD == 0 and cedit.cval['DragPos'] and cedit.cval['DragPos'].hmouse then
local rc = {}
U.dump(out.ahole, '??__________ inhole:'..tostring(base2world(adesc[cedit.mesh], cij))..':'..tostring(cw.u))
for i=1,4 do -- in pairs(out.ahole) do
-- cw.achild.cur = #cw.achild
-- U.dump(rc, '?? for_rc:')
elseif cedit.cval['DragRot'] and scope == 'floor' then
ij = forHit(ray, adesc[cedit.mesh])
U.dump(ij, '?? mup_post_HIT:')
if ij then cij = ij end
if out.aedge then
U.dump(out.aedge, '?? for_edge:'..tostring(out.aedge.top))
if out.inedge and out.inedge[1] == out.aedge.ij[1] and out.inedge[2] == out.aedge.ij[2] then
else
U.dump(out.aedge.ij, '?? PIN:')
out.inedge = out.aedge.ij
local desc = adesc[cedit.mesh]
-- U.dump(cij, '?? for_cij:'..tostring(desc))
local cfloor
-- local pm = (U.mod(j-2,base) + U.mod(j+3, base))/2
-- U.dump(base, '?? to_MIDDLE:')
local um = (U.mod(j+1,base) - base[j])/2
-- split
U.dump(out.wsplit, '?? for_split_alt:'..tostring(scope)..':'..id..':'..tostring(aedit[id]))
if aedit[id] then
floor.top.achild = {}
-- U.dump(floor.top.achild, '?? childs:')
wallSplit()
-- APPEND to selection
U.dump(ij, '?? to_APPEND:'..nm)
if nm == forestName then
end
-- U.dump(cedit.aforest, '?? cedit_AF:')
markUp()
end
U.dump(ij, '?? mup.for_hit:'..nm..':'..tostring(editor.keyModifiers.ctrl))
if editor.keyModifiers.ctrl and not sindrag then --and U._MODE ~= 'conf' then
-- local rCast = cameraMouseRayCast(false)
-- U.dump(dforest[key], '?? for_forest:'..tostring(scope)..':'..tostring(dforest[key] and dforest[key].type or nil)..':'..tostring(key)..'/'..tostring(cedit.forest)..':'..tostring(cedit.fscope)) --..':'..tostring(rCast.object.name)) --..':'..tostring(dforest[key].mesh)..':'..tostring(cedit.fscope))
if not key or not dforest[key] then return end
lo('?? tof2:'..key..' fscope:'..tostring(cedit.fscope)..':'..dforest[key].type..':'..tostring(dforest[key].mesh)..':'..tostring(cedit.mesh)..':'..tostring(#cedit.aforest), true)
-- U.dump(dforest[key], '?? tof2:'..dforest[key].type, true)
local dae = U.forOrig(dforest[key].item:getData():getShapeFile())
end
-- U.dump(w.df[dae], '?? for_key:'..dae)
-- lo('??_____________________ for_DF:'..tostring(desc.afloor[ij[1]].df))
-- lo('?? found:'..tostring(out.curselect),true)
-- U.dump(daePath[tp],'?? cs:'..tp..':'..tostring(sij)..':'..dae) --..':'..dforest[key].type)
-- lo('?? di:'..daeIndex(dforest[key].type, dae))
ij = forHit(ray, adesc[cedit.mesh])
U.dump(ij, '?? for_desc:'..id..':'..tostring(adesc[id])..':'..tostring(cedit.mesh)..' cursel:'..tostring(out.curselect))
if ij then
local scopenew = scope
U.dump(ij, '??__________________ mup_SCOPE:'..tostring(scope)..':'..tostring(ij))
-- U.dump(cij, '?? cij:')
U.dump(ij, '??__________________ mup_SCOPE:'..tostring(scope)..':'..tostring(ij))
-- U.dump(cij, '?? cij:')
if ij then
local ihole = U.inRC(world2wall(rayCast.pos, cw), cw.achild, 'base')
-- U.dump(cw.achild, '?? if_HOLE:'..tostring(ihole)..':'..tostring(world2wall(rayCast.pos, cw)))
if ihole then
cw.achild.cur = ihole
U.dump(cw.achild[cw.achild.cur], '?? in_hole:'..ihole)
out.ahole = {}
out.ahole[#out.ahole+1] = out.ahole[1]
-- U.dump(out.ahole, '?? hole:'..ihole)
out.inhole = cw
else
-- U.dump(cij, '?? cij:')
-- U.dump(ij, '?? ij:')
-- U.dump(cij, '?? cij:')
-- U.dump(ij, '?? ij:')
-- U.dump(cw.achild, '?? if_empty:')
-- U.dump(ij, '?? ij:')
-- U.dump(cw.achild, '?? if_empty:')
-- clean unfilled holes
for i,c in pairs(floor.top.achild) do
-- U.dump(c, '?? for_LIST:'..i..':'..inrc..' scch:'..tostring(scchild)..':'..#U.index(c.list, inrc))
if #U.index(c.list, inrc) > 0 then
lo('?? inrc:'..tostring(inrc)..':'..tostring(floor.top.cchild)..':'..scopenew)
-- U.dump(floor.top.achild, '?? achild:')
scopeOn(scopenew)
-- lo('?? mup_mat:'..tostring(cmat)..':'..tostring(out.curselect))
-- U.dump(cij, '?? pre_SCOPE:'..scopenew..':'..tostring(out.curselect)..':'..tostring(dmat.wall[out.curselect or 0])..':'..tostring(cmat))
forBuilding(desc, function(w, ij)
end
U.dump(cij, '<< mup:'..tostring(scope)..':'..tostring(ij)..':'..tostring(cedit.mesh)..' forest:'..tostring(cedit.forest)..':'..#adesc..' cursel:'..tostring(out.curselect))
return ij
else
U.dump(out.aedge[1].ij, '?? PIN:')
out.inedge = out.aedge[1].ij
-- local pm = (U.mod(j-2,base) + U.mod(j+3, base))/2
U.dump(base, '?? to_MIDDLE:')
lo('?? UPDTD:'..id) --..':'..tostring(c)..':'..speed)
-- U.dump(dmesh[id].sel[1].ref, '?? for_REF:')
else
-- out.frame = nil
-- U.dump(dmesh[cmesh].incube[1].ref, '?? cube_OFF:')
-- U.dump(dmesh[cmesh].sel[1].faces, '?? sel:')
-- U.dump(dmesh[cmesh].incube[1].ref, '?? cube_OFF:')
-- U.dump(dmesh[cmesh].sel[1].faces, '?? sel:')
-- dmesh[cmesh].sel = dmesh[cmesh].incube
if not floor then
U.dump(desc.afloor, '!! NO_FLOOR:')
return
p.z = 0
-- U.dump(lastFloor.top.body, '?? mup.floors:'..#adesc[cedit.mesh].afloor..':'..tostring(p))
local inrc = U.inRC(p, lastFloor.top.body)
-- APPEND to FOREST SELECTION
U.dump(cij, '?? app_FOREST:'..key..':'..dforest[key].type)
local sij
end
U.dump(desc.selection, '?? f_sle:')
markUp(nil, dforest[key].type)
elseif not newedit then
-- U.dump(cij, '?? NARROW_DOWN:'..nm)
if cedit.part ~= nil then
end
-- U.dump(cij, '?? NARROW_DOWN2:'..nm)
-- lo('?? mup_scope:'..objLevel)
local desc = adesc[cedit.mesh]
U.dump(cij, '?? wall_sel_append:'..rayCast.object:getID()..':'..rayCast.object.name..':'..tostring(desc.selection))
if not desc.selection then desc.selection = {} end
end, ij)
U.dump(desc.selection, '?? SELED:')
--[[
end
U.dump(desc.selection, '?? for_sel:')
-- scope = nil
if floor and #floor.top.achild > 0 then
-- U.dump(floor.top.achild,'?? childs:'..#floor.top.achild..':'..cij[1])
local scchild = floor.top.cchild
for i,c in pairs(floor.top.achild) do
-- U.dump(c, '?? for_LIST2:'..i..':'..inrc..' scch:'..tostring(scchild)..':'..#U.index(c.list, inrc))
if #U.index(c.list, inrc) > 0 then
lo('?? inrc:'..tostring(inrc)..':'..tostring(floor.top.cchild))
-- U.dump(floor.top.achild, '?? achild:')
markUp()
-- out.avedit = {vec3(0, 0, 6)}
-- U.dump(out.avedit, '<< mup:'..#out.avedit)
U.dump(cij, '<< mup:'..tostring(cmesh))
-- U.dump(out.avedit, '<< mup:'..#out.avedit)
U.dump(cij, '<< mup:'..tostring(cmesh))
return true
end
U.dump(aface, '?? for_VERTS:'..#aedit[id].mesh[1].verts)
]]
local margin = forTop().margin
-- U.dump(base, '?? for_floor:')
if floor.top.cchild then
aint = U.polyCross(base, lmouse, dpos:cross(vec3(0,0,1)))
-- U.dump(aint, '?? wspl: pos:'..tostring(pos)..' cm:'..tostring(cmouse)..':'..#out.wsplit)
if #aint == 2 then
end
-- U.dump(aint,'?? aint:'..#aint..':'..tostring(adesc[cedit.mesh].pos))
if #aint == 2 then
-- out.wsplit = {aint[1][1],aint[2][1]}
-- U.dump(aint, '?? point.aint:')
-- rerender for mouse being properly detected
for j,d in pairs(a) do
-- U.dump(d, '?? for_D:'..d.id..':'..id..':'..tostring(tostring(d.id) == tostring(id)))
if tostring(d.id) == tostring(id) then
local cij = aedit[id].desc.ij
-- U.dump(ij, '?? for_desc:')
-- _dbdrag = true
if ({wall=1})[scope] then
U.dump(buf,'?? split_HOR:'..cij[2]..':'..#buf)
forBuilding(desc, function(w, ij)
]]
-- U.dump(buf, '?? split_buf:')
-- if d < 0 or (d + u) >= w.u:length() then return end
-- p = p + u*un
-- U.dump(out.asplit, '?? for_split:')
end
end
-- U.dump(out.asplit, '??+++++++++++++++++++++ for_split:')
end
-- resize apeend mark
-- U.dump(cedit.cval, '?? mark_RESIZE:')
local u,v = cedit.cval['AltZ'][1],cedit.cval['AltZ'][2]
-- local w = floor.awall[1]
-- U.dump(w.uv,'??++++++++ for_w:'..tostring(w.v))
houseUp(adesc[cedit.mesh], cedit.mesh)
end
-- U.dump(desc.selection, '?? ctrl_WHEEL:')
local desc = adesc[dforest[cedit.forest].mesh]
U.dump(desc.afloor[2].awall[1].df, '?? FOREST_scale:'..tostring(dforest[cedit.forest].type))
if not cedit.cval['DragScale'] then cedit.cval['DragScale'] = {} end
w.df[w.win].scale = w.df[w.win].scale*(1 + 0.02*dir)
-- U.dump(desc.afloor[2].awall[1].df, '?? post_scale:'..w.df[w.win].scale)
end)
end)
-- U.dump(desc.afloor[2].awall[1].df, '?? scaled:')
houseUp(desc, cedit.mesh, true)
local asij = forSide()
-- U.dump(asij, '?? asij:')
for i,f in pairs(asij) do
-- resize apeend mark
-- U.dump(cedit.cval, '?? mark_RESIZE:')
else
end
-- U.dump(aedit[cedit.part].desc, '?? for_margins:'..cedit.part)
-- _dbdrag = true
-- flip tops
U.dump(s_top, '?? s_top:'..tostring(s_top))
if floor.top and s_top then
]]
-- U.dump(desc.afloor[1].top, '?? top1:')
-- U.dump(desc.afloor[2].top, '?? top2:')
-- U.dump(desc.afloor[1].top, '?? top1:')
-- U.dump(desc.afloor[2].top, '?? top2:')
houseUp(desc, cedit.mesh)
if house.selection then
U.dump(house.selection, '??******* CLONE SELECTION:')
local afloor = {}
local desc = adesc[dforest[cedit.forest].mesh]
-- U.dump(cij, '?? keyRL_cij:')
local floor, iwall
forBuilding(desc, function(w, ij)
-- U.dump(ij, '?? keyRL_ij:')
if w.doorind ~= nil then
-- U.dump(desc, '?? wdesc:')
-- lo('?? desc:'..tostring(desc.doorind))
end
-- U.dump(cij,'<< keyShift:')
end
-- out.apoint = {center + vec3(0,0,6)}
U.dump(base, '?? to_AROUND:'..scope..':'..cij[1]..':'..tostring(center))
cedit.cval['CamRot'] = {
-- lo('?? goAround:'..tostring(obj:getPosition()))
-- U.dump(adesc[cedit.mesh], '?? desc:')
local conf = jsonReadFile(setfile)
U.dump(conf,'?? check:'..tostring(setfile))
FS:removeFile(setfile)
end
U.dump(dset, '?? for_DSET:')
out.R.clear(groupEdit)
if out.inhole.achild then
-- U.dump(out.inhole.achild[#out.inhole.achild], '?? HOLE:')
local cw = out.inhole
if floor.top.cchild then
-- U.dump(floor.top.achild, '?? achild:')
floor.top.cchild = nil
end
U.dump(floor.awplus, '?? fAW:')
roofSet('flat')
-- lo('?? ACORN0:')
U.dump(out.acorner, '?? acorn:')
for i,c in pairs(out.acorner) do
if out.asplit then
-- U.dump(out.asplit, '?? mark_split:')
for _,e in pairs(out.asplit) do
-- if row.noz then
-- U.dump(row, '?? if_CORNER:'..tostring(out.acorner))
-- end
-- lo('?? ACORN0:')
-- U.dump(out.acorner, '?? acorn:')
for _,c in pairs(out.acorner) do
-- lo('?? inCORN:'..i..':'..j) --..':'..incorner)
-- U.dump(pth, '?? atCORN:'..#pth..':'..i..':'..j)
-- clr = ColorF(0,1,1,0.1)
-- if rayCast.pos:distanceToLine(p, p + vec3(0,0,1))/(core_camera.getPosition() - rayCast.pos):length() < 0.02 then
-- U.dump(aedit[id].desc.ij, '?? for_CORNER:'..id)
-- _dbdrag = true
end
-- U.dump(aedit[id].desc.ij, '?? for_ij:'..tostring(otype))
local ijhit
-- U.dump(ij, '?? if_hit:')
local istop
if U._PRD==0 and ijhit then
-- U.dump(ijhit, '?? ijhit:'..tostring(istop))
out.aedge = {e = {}, ij = ijhit, top = istop}
end
-- U.dump(aside, '?? PM:'..tostring(mi)..':'..tostring(ma)..':'..tostring(u)..':'..cij[2])
if mi and ma then
end
-- U.dump(aside, '?? for_side_m: i='..cij[1]..':'..mi..':'..ma)
-- local pm = (base2world(desc, {cij[1],mi}) + base2world(desc, {cij[1],U.mod(ma+1,#base)}))/2
out.middle = {line = {pm, pm + vec3(0,0,desc.afloor[cij[1] ].h)}, ij = cij}
-- U.dump(aside, '?? for_side:'..cij[1]..':'..#aside[cij[1] ]..':'..tostring(pm))
-- _dbdrag = true
-- if out.acorner then
-- U.dump(out.acorner, '?? acorn0:')
-- end
-- lo('?? fj1:'..tostring(desc.pos)..':'..tostring(desc.id))
-- U.dump(desc.pos, '?? fj1:'..tostring(desc.pos))
houseUp(desc)
if desc.prn then
U.dump(adesc[desc.prn].selection, '?? to_COPY_fromparent:')
else
else
U.dump(desc.selection, '?? to_COPY:')
end
end
U.dump(incopy[cedit.mesh], '?? copied:')
-- elseif im.IsKeyPressed(im.GetKeyIndex(im.Key_V)) then
-- PASTE
U.dump(incopy[cedit.mesh], '??+++++++++++++++++++++++++++++++ to_PASTE:'..tableSize(incopy)..':'..tostring(out.invertedge))
-- TODO: for between buildings
table.sort(akey)
U.dump(akey, '?? sorted:')
local dsrc = adesc[id]
local dsrc = adesc[id]
U.dump(buf, '?? for_them:'..tostring(dsrc)..':'..tostring(scope))
local ftgt = desc.afloor[cij[1]]
local ij = out.invertedge.ij
-- U.dump(buf, '?? INSERT:'..ij[2])
local ftgt = desc.afloor[ij[1]]
local dir = U.less(p, psrc, u)
-- U.dump(ftgt.base, '?? base_PRE:'..ij[2])
-- if true then return end
p = ftgt.base[ij[2]]
U.dump(ftgt.base, '?? base_SHIFTED:'..ij[2])
-- lo('?? ins_POST:'..#ftgt.base, true)
-- U.dump(ftgt.base, '?? for_BASE2:')
baseOn(ftgt)
baseOn(ftgt)
-- U.dump(ftgt.base, '?? insed:'..#ftgt.base..':'..#ftgt.awall, true)
-- U.dump(ftgt.base, '?? for_BASE3:')
-- U.dump(ftgt.base, '?? insed:'..#ftgt.base..':'..#ftgt.awall, true)
-- U.dump(ftgt.base, '?? for_BASE3:')
end
elseif scope == 'floor' then
U.dump(buf, '?? for_FLOOR:'..tostring(buf))
if #akey == 1 then
elseif scope == 'wall' then
U.dump(buf,'?? REPLACE:'..#akey)
if #akey == 1 then
if sameSide(buf) then
U.dump(cij, '?? SSide:'..cij[1])
U.dump(desc.selection, '?? if_sel:'..tableSize(desc.selection))
U.dump(cij, '?? SSide:'..cij[1])
U.dump(desc.selection, '?? if_sel:'..tableSize(desc.selection))
end
U.dump(buf, '?? to_coll:')
wallCollapse(desc, buf)
local acol = {}
U.dump(buftgt, '?? BT:')
for i,r in pairs(buftgt) do
end
U.dump(ftgt.base, '?? ftgt_post:'..#acol..':'..#ftgt.base..':'..#ftgt.awall)
-- insert
table.sort(akeytgt)
U.dump(akeytgt, '?? keytgt:')
]]
local floor = desc.afloor[cij[1]]
U.dump(floor.base, '?? base_pre:')
-- go over source side
-- table.insert(floor.awall,cij[2],wnew)
-- U.dump(fsrc.awall[1], '?? fsrc:'..#fsrc.awall)
-- U.dump(fsrc.awall[1], '?? w_src:')
-- U.dump(floor.awall[4], '?? w_tgt:')
-- U.dump(fsrc.awall[1], '?? w_src:')
-- U.dump(floor.awall[4], '?? w_tgt:')
-- U.dump(floor.base, '?? new_base:'..#floor.awall)
-- U.dump(floor.awall[4], '?? w_tgt:')
-- U.dump(floor.base, '?? new_base:'..#floor.awall)
-- baseOn(fsrc)
-- PASTE child to floor
U.dump(buf, '?? to_PASTE_f:'..cij[1]..':'..tostring(floor.pos))
U.dump(akey, '?? for_topaste:'..tostring(floor.pos)..':'..tostring(scope))
U.dump(buf, '?? to_PASTE_f:'..cij[1]..':'..tostring(floor.pos))
U.dump(akey, '?? for_topaste:'..tostring(floor.pos)..':'..tostring(scope))
-- U.dump(desc.afloor[2].top, '?? 2nd_floor_PRE:'..#desc.afloor[2].awall)
U.dump(akey, '?? for_topaste:'..tostring(floor.pos)..':'..tostring(scope))
-- U.dump(desc.afloor[2].top, '?? 2nd_floor_PRE:'..#desc.afloor[2].awall)
--- make building
if #buf[akey[i]] == #dsrc.afloor[akey[i]].base then
-- U.dump(desc.afloor[akey[1]].top, '?? whole:'..i..':'..akey[i])
table.insert(dnew.afloor, 1, deepcopy(dsrc.afloor[akey[i]]))
if out.asplit then
U.dump(out.asplit, '?? OAC:')
end
-- lo('?? AC2:')
-- U.dump(out.acorner, '?? AC2:')
for _,e in pairs(out.acorner) do
elseif out.asplit then
-- U.dump(out.asplit, '?? mark_split:')
for _,e in pairs(out.asplit) do
if s.areg then
-- U.dump(s.aforest,'>> windowsToggle:'..tostring(s))
for _,h in pairs(s.areg) do
local H = forHeight(adesc[cedit.mesh].afloor,ij[1]-1)
U.dump(av, '?? AV:'.._..':'..H..':'..ij[1])
local start = av[1]
end
U.dump(s.ahole, '?? wT_AHOLE:'..#s.areg)
out.ahole = nil
lo('?? wT_def:'..#s.aforest)
-- U.dump(s,'?? s_FOR:')
if #s.aforest>0 then
end
-- U.dump(s.ahole, '?? aHOLE:')
return
wplus.win = {dae = daePath.win[1]}
U.dump(wplus, '?? wT_wplus:')
else
local function doorToggle()
U.dump(cij, '>>--------- doorToggle:'..tostring(cedit.part)..':'..scope)
local wdesc
forBuilding(adesc[cedit.mesh], function(w, ij)
-- U.dump(w, '?? doorToggle:')
if w.doorind ~= nil then
w.doorind = math.ceil(#w.df[w.win]/2)
U.dump(cij, '??____ DOOR_IND:'..w.doorind)
wdesc = w
wdesc = adesc[cedit.mesh].afloor[cij[1]].awall[cij[2]]
U.dump(wdesc.achild, '?? aCHILD:'..tostring(wdesc.door))
-- wdesc.df[wdesc.door] = {}
if wdesc ~= nil then
-- U.dump(wdesc.df, '?? for_DF:'..tostring(wdesc.door))
local list = wdesc.df[wdesc.door]
indrag = false
U.dump(cij, '>> pillarSpan:'..n)
forBuilding(adesc[cedit.mesh], function(w, ij)
w.pillar.down = forHeight(adesc[cedit.mesh].afloor, ij[1] - 1) - forHeight(adesc[cedit.mesh].afloor, ij[1] - 1 - n)
-- U.dump(w.ij, '?? for_down:'..w.pillar.down..':'..n)
end)
local function pillarToggle()
U.dump(cij, '>> pillarToggle:')
if cij[1] == 1 then return end
w.pillar = deepcopy(default.pillar)
-- U.dump(default.pillar,'?? p_new:'..ij[2]..':'..tostring(w.pillar.yes))
end
local acorner = cornersBuild(desc, dae)
-- U.dump(acorner, '??^^^^^^^^^^^^^^^^^^ CB:')
-- U.dump(desc.acorner_, '??^^^^^^^^^^^^^^^^^^ CB_dac:')
-- U.dump(acorner, '??^^^^^^^^^^^^^^^^^^ CB:')
-- U.dump(desc.acorner_, '??^^^^^^^^^^^^^^^^^^ CB_dac:')
if desc.acorner_ then
if desc.acorner_ then
-- U.dump(desc.acorner_, '?? to_SUBTRACT:', true)
for n,p in pairs(acorner) do
break
-- U.dump(q.list, '??++++++++++++++++++++++ to_ADD:')
end
isext = true
-- U.dump(p, '?? HIT_fr:')
-- U.dump(q, '?? HIT_to:')
-- U.dump(p, '?? HIT_fr:')
-- U.dump(q, '?? HIT_to:')
local hit
end)
-- U.dump(q.list, '??++++++++++++++++++++++ to_ADD:')
end
end
-- U.dump(desc.acorner_, '??****************************** post_REM:'..tostring(dae))
-- desc.acorner_ = nil
if string.find(dobj.dae, '/'..spart) then
-- U.dump(dobj, '?? for_CRN:'..s..':'..spart,nil,2)
return s
dobj.margin = dobj.margin/3
-- U.dump(ddae[pth],'?? corner:'..tostring(dobj.margin)..':'..pth)
end
local ind = string.find(dobj.dae,'_SC_',1,true)
U.dump(daePath['stringcourse_corner'],'?? if_IND:'..tostring(ind)..':'..#daePath['stringcourse_corner'])
if ind then
local daestairs
-- U.dump(dpart[dae], '??^^^^^^ toggle_FS:')
if dpart[dae] then
local desc = adesc[cedit.mesh]
-- U.dump(desc.acorner, '?? toggle_corner:'..scope, true)
out.curselect = 1
W.cornerUp(desc)
-- U.dump(desc.acorner_, '?? CB:')
-- desc.acorner_ = nil
-- indrag = false
-- U.dump(daePath[tp], '?? toggle_PIL:')
local w
local cw = desc.afloor[w.ij[1]].awall[j]
U.dump(cw.ij, '?? clean1:')
forestClean(cw)
-- adel[#adel+1] = cw
-- U.dump(adel[#adel].ij, '?? to_DEL1:')
end
if U.proj2D(d.pos):distance(p) < small_dist and d.pilaster then
U.dump(d.ij,'?? clean2:'..i..':'..k)
forestClean(d)
if cw and cw.pilaster and cw.pilaster.to then
-- U.dump(cw.pilaster, '?? if_BREAK:'..cw.ij[1]..':'..cw.ij[2])
cw.pilaster = {}
-- lo('?? to_DEL:'..#adel)
U.dump(dfirst,'?? to_DEL:'..ndel)
for f,jfirst in pairs(dfirst) do
buf[d.ij[1] ] = {d.ij[2]}
U.dump(buf, '??^^^^ to_DEL:'..d.ij[2])
wallCollapse(desc, buf)
local onside = sameSide(desc.selection)
-- U.dump(desc.selection, '?? for_PILAST:'..tostring(onside))
if not onside then return end
-- local aind = {}
U.dump(desc.selection,'?? if_SPLiT:'..tostring(W.ui.pilaster_nsplit))
local p, w
local span = tableSize(desc.selection)
-- U.dump(desc.selection, '?? for_SPLIT:'..lastrow)
for i,s in pairs(asplit) do
for i,s in pairs(asplit) do
-- U.dump(s, '??______************ for_S:'..i..':'..s[1]..'/'..lastrow)
local floor = desc.afloor[s[1]]
-- lo('?? in_SPLIT:'..cj..'/'..s[2]..':'..#floor.awall)
-- U.dump(desc.selection[lastrow], '?? if_TO:'..cj..'/')
floor.awall[cj].pilaster = {
}
-- U.dump(floor.awall[cj].pilaster, '?? for_PIL:')
else
]]
-- U.dump(w.storefront.adae, '??++++++++++++++ for_PERM:'..lwall)
-- w.storefront.ind = w.doorind and w.doorind+1 or 1
-- w.storefront.ind = w.doorind and w.doorind+1 or 1
-- U.dump(ddae[daePath[tp][1]], '?? for_dae:')
-- w.storefront.dae =
local acorner = cornersBuild(desc, out.curselect)
U.dump(acorner, '?? cornerToggle.acorner:')
desc.acorner = acorner
local acorner = cornersBuild_(desc)
U.dump(acorner, '?? CB:')
if desc.acorner_ then
if desc.acorner_ then
-- U.dump(desc.acorner_, '?? to_SUBTRACT:', true)
for _,p in pairs(acorner) do
if (p.pos-q.pos):length() < small_dist then
-- U.dump(p, '?? HIT_fr:')
-- U.dump(q, '?? HIT_to:')
-- U.dump(p, '?? HIT_fr:')
-- U.dump(q, '?? HIT_to:')
local hit
end)
-- U.dump(q.list, '??++++++++++++++++++++++ to_ADD:')
end
end
-- U.dump(desc.acorner_, '??****************************** post_REM:')
-- desc.acorner_ = nil
local function forDAE(tp)
-- U.dump(daePath['win'], '?? forDAE:'..tp)
-- return U.clone(ddae[tp])
-- if not _dbdrag then
-- U.dump(list, '??>>>> forDAE:'..tp..':'..#list)
-- _dbdrag = true
if #U.index(atp, dforest[cedit.aforest[1] ].type)>0 and W.forSpline() then
U.dump(atp,'?? for_TRUE:'..tostring(dbg)..':'..tostring(W.out.inhole))
return true
if W.ui.dbg and atp[1] == 'corner' then
U.dump(atp, '?? ifForest:'..tostring(atp)..':'..tostring(cedit.forest)..':'..tostring(dforest[cedit.forest]))
end
W.ifPairEnd = function(ij,dbg)
-- U.dump(cij, '>> ifPairEnd:')
local forhit
end
if dbg then U.dump(incorner, '>> ifPairEnd:'..tostring(forhit)..':'..tostring(incorner)..' cij:'..tostring(cij and cij[1] or nil)..':'..tostring(cij and cij[2] or nil), true) end
if not ij then
end
if dbg then U.dump(imap, '?? iPE_base:'..cij[2]..'/'..ij[2]..' base_orig:'..#floor.base) end
if dbg then
U.dump(apair, '?? ifPairEnd_PAIRS:'..tostring(forhit))
end
-- local adata,apair = T.forGable(floor.base)
if dbg then U.dump(apair,'?? if_pairs_end:'..tostring(forhit)..':'..ij[2]..':'..tostring(isHit(ij[2],apair[1]))) end
if apair then
end
if dbg then U.dump(apair[i],'?? if_FIT:'..ij[2]..':'..tostring(ifit)) end
if ifit then
local fit = forhit and isHit(ij[2],apair[i]) or isFit(ij[2],apair[i])
if dbg then U.dump(apair[i],'?? for_FIT:'..tostring(fit)..':'..ij[2]) end
if fit then
elseif isFit(cij[2],apair[#apair]) then
-- U.dump(apair, '?? isPairEnd:'..cij[1]..':'..tostring(cij[2]), true)
return (incorner and 1 or 2),apair[#apair]
if W.ui.dbg then
U.dump(base, '??^^^^^^^^^^^^^^^^^^^^^^ child_BASE:')
W.ui.dbg = nil
if W.ui.dbg then --and nm ~= 'flat' then
U.dump(base, '?? ifRoof_pyr:')
W.ui.dbg = false
if out.inridge then
U.dump(desctop, '??___________________________________________ for_DESC:'..tostring(floor.top.cchild))
out.inridge = false
]]
-- U.dump(floor.top, '>> ifTopRect:'..tostring(cij[1]))
end
-- if wall ends are in the child vertex mapping
-- U.dump(c, '?? tostring:'..ib)
local aind = U.index(c.imap, ib)
if #aind > 0 then
-- U.dump(c, '?? for_child: floor:'..i..' wall:'..j..':'..#aind)
for _,ic in pairs(aind) do
-- end
-- U.dump(cbase,'?? move_c_base: child:'..k..':'..ib..'/'..j..':'..ic..':'..tostring(pchild))
if toemu then
local acbase = sdata.cbase
-- U.dump(buf, '>> extrude:')
lo('>> extrude:'..tostring(rebased), true)
-- if tableSize(buf) > 1 or not sameSide(buf) then return end
-- U.dump(buf, '>> extrude:'..tostring(rebased))
-- U.dump(asbase, '?? asbase:')
-- U.dump(buf, '>> extrude:'..tostring(rebased))
-- U.dump(asbase, '?? asbase:')
-- local floor = adesc[cedit.mesh].afloor[cij[1]]
tbuf[i] = aj
-- U.dump(tbuf, '?? mm:'..mi..':'..ma)
if sameSide(tbuf) then
tbuf[i] = aj
-- U.dump(tbuf, '?? mm2:'..mi..':'..ma)
if sameSide(tbuf) then
table.insert(floor.base, mi, floor.base[mi])
-- U.dump(floor.base, '?? to_ins_at_mi:'..i..':'..mi)
local w = deepcopy(floor.awall[mi])
-- lo('?? post_INS:'..#floor.awall,true)
-- U.dump(floor.base, '?? new_base:'..tostring(v))
-- U.dump(r, '?? newbuf:')
-- U.dump(floor.base, '?? new_base:'..tostring(v))
-- U.dump(r, '?? newbuf:')
end
end
-- U.dump(r, '?? extr_FLOOR:'..i..':'..tostring(val))
-- move base
-- lo('?? to_move:'..j, true)
-- U.dump(asbase[i], '??_______________ bases:')
base[U.mod(j,#base)] = asbase[i][U.mod(j,#asbase[i])] + v*val
for _,ib in pairs({j,U.mod(j+1,#base)}) do
-- U.dump(c.imap, '?? in_map:'..ib..' j:'..j)
-- if wall ends are in the child vertex mapping
if #aind > 0 then
-- U.dump(c, '?? for_child: floor:'..i..' wall:'..j..':'..#aind)
for _,ic in pairs(aind) do
if math.abs((vb-pchild):length()+(ve-pchild):length()-(vb-ve):length()) < small_dist then
U.dump(acbase[i][k],'?? move_c_base:'..ib..':'..ic..':'..tostring(pchild))
c.base[ic] = acbase[i][k][ic] + v*val
end
-- U.dump()
end
baseOn(floor)
-- U.dump(floor.base, '?? after_SPLIT:')
end
--[[
U.dump(out.ahole, '?? for_cur:')
if false then
local m = aedit[w.id].mhole
-- U.dump(m, '?? for_cur:'..cur)
local av = {}
local un = w.u:normalized()
U.dump(av, '?? h_IVERTS:'..tostring(w.u)..':'..tostring(dmesh[w.id]))
for _,v in pairs(av) do
forBuilding(desc, function(w,ij)
-- U.dump(w.df, '?? for_wall:'..ij[1]..':'..ij[2])
for pth,list in pairs(w.df) do
-- lo('?? for_fi:'..tostring(item)..':'..tostring(pos)..':'..tostring(scale)..':'..tostring(rot))
-- U.dump(editor.matrixToTable(item:getTransform()), '?? for_fi:'..tostring(item)..':'..tostring(pos)..':'..tostring(scale)..':'..tostring(rot))
-- U.dump(trans,'?? for_fi:'..tostring(item)..':'..tostring(pos)..':'..tostring(scale))
-- U.dump(editor.matrixToTable(item:getTransform()), '?? for_fi:'..tostring(item)..':'..tostring(pos)..':'..tostring(scale)..':'..tostring(rot))
-- U.dump(trans,'?? for_fi:'..tostring(item)..':'..tostring(pos)..':'..tostring(scale))
local oid,om = f2m(pth, id)
-- lo('?? onVal:'..key..':'..tostring(val))
if not incontrol then U.dump(cij, '?? W.onVal:'..tostring(key)..':'..tostring(val)) end --..':'..tostring(out.inseed)..':')
local sval = W.ui[key]
wp = U.mod(wp.ij[2]-wp.pilaster.ind+1, awall)
-- U.dump(wp.pilaster, '?? for_PRN:'..wp.ij[2])
local buf = {}
end
U.dump(buf, '?? for_BUF:')
desc.selection = buf
elseif key == 'gutter_margin' then
-- U.dump(desc.afloor[2].awall[1].gutter,'??^^^^^^^^^***** GM:'..val)
forBuilding(desc, function(w, ij)
local desc = adesc[cedit.mesh]
U.dump(desc.selection,'?? wall_spline:')
local s = W.forSpline()
-- lo('??******************************************* AF:'..#af)
-- U.dump(af, '??******* AF:'..#af)
-- to DAE
end
U.dump(dpos, '??******************************* DPOS:')
-- render forest
local ascan = W.buildingScan(desc, function(ascan)
-- U.dump(ascan, '?? for_SCAN:')
local auv = tex2uv(ascan)
local auv = tex2uv(ascan)
-- U.dump(auv, '?? for_SCAN:')
local arc = {}
end)
U.dump(arc, '?? for_SCAN:')
--TODO: automate texture merging
end, true)
U.dump(aid, '?? post_recover:'..tableSize(adesc)..':'..#aid) --istart)
--[[
dnew.afloor = {child}
-- U.dump(c,'?? c_BASE:'..cij[1])
child.awall = {}
end
-- U.dump(floor.top,'?? if_TOP:'..tostring(floor.top.id))
objDown(floor.top)
floor.top = nil -- {ridge={}}
U.dump(floor,'??_____ floor_CLEANED:')
-- get common verts
local desctop = forTop()
-- U.dump(desctop, '?? DT:')
if desctop.ridge and desctop.ridge.on and #desctop.base ~= 4 then
local dae = ddae[w.doorstairs[w.doorind].dae]
-- U.dump(dae, '?? stairs_toggle:', true)
if ij[1] == 2 then
local floorpre = desc.afloor[1]
-- U.dump(desc.afloor[1].awall[1], '?? floor_PRE:'..tostring(desc.afloor[2].pos))
local floor = {ij = {1}, base = deepcopy(desc.afloor[1].base), pos = floorpre.pos,
if desc.acorner_ then
-- U.dump(desc.acorner_, '?? corners_shift:')
for i,b in pairs(desc.acorner_) do
lo('?? pre_ridged:'..tostring(floor.top.id)..':'..#floor.top.achild..':'..tostring(floor.top.achild[1]))
-- U.dump(floor.top.achild[1], '?? pre_ridged:'..tostring(floor.top.id))
if #floor.top.achild == 1 then
end
-- U.dump(floor.top,'?? ridge_flat:')
elseif key == 'stringcourse_bottom' then
dae = w.pilaster.dae
-- U.dump(w.pilaster.aind, '??___________ AIND2:')
end
dae = w.pilaster.dae
U.dump(w.pilaster.aind, '??___________ AIND:'..ij[1]..':'..ij[2]..tostring(cedit.mesh)..':'..tostring(cij[2]))
end
end
-- U.dump(cedit.cval['DragPos'].cbase, '?? child_BASES:')
local dmove = {}
end
-- U.dump(dmove, '?? to_move:')
for ic,c in pairs(cedit.cval['DragPos'].cbase) do
if floor.awplus[ic] then
-- U.dump(floor.awplus[ic], '?? for_AW:')
if floor.awplus[ic].id then
if floor.awplus[floor.top.cchild] then
-- U.dump(floor.awplus[floor.top.cchild], '?? for_AWP:')
floor.awplus[floor.top.cchild].dirty = true
local b = cw.achild[cw.achild.cur or #cw.achild]
-- U.dump(b.base, '?? for_b:')
if b.body then
-- lo('?? hole_fitmesh.WH:'..tostring(doorH)..':'..tostring(doorW))
-- U.dump(b.base, '??______ for_hole_mesh:'.._..':'..b.body..':'..ang..':'..tostring(desc.pos))
local scale = vec3(doorW/w, 1, doorH/h)
-- U.dump('?? scale:'..tostring(scale))
b.base[1].y = b.base[2].y + h*scale.z
b.base[4].x = xmid + doorW/2
-- U.dump(b.base, '?? for_b2:')
-- reset frame
if out.inhole and out.inhole.achild then
-- U.dump(out.inhole.arc, '?? hole_x:'..cedit.mesh..':'..tostring(aedit[cedit.mesh]))
local ahole = out.inhole.achild
-- local irc = U.inRC(base[1] + val*vec3(1,0,0), {out.inhole.arc[6]})
-- U.dump(out.inhole.arc[6], '?? if_RC:'..tostring(irc)..':'..tostring(base[1]))
-- U.dump(out.inhole.arc[6], '?? if_RC:'..tostring(irc)..':'..tostring(base[1]), true)
-- U.dump(out.inhole.arc[6], '?? if_RC:'..tostring(irc)..':'..tostring(base[1]))
-- U.dump(out.inhole.arc[6], '?? if_RC:'..tostring(irc)..':'..tostring(base[1]), true)
-- lo('?? if_in:'..i..':'..tostring(ind)..':'..#out.inhole.arc)
local rollback
-- U.dump(base, '?? if_IN:'..val)
for i = 1,#base do
houseUp(nil, cedit.mesh)
U.dump(cij,'?? for_nfl:'..#desc.afloor)
elseif key == 'building_ang' or key == 'ang_floor' then
for k,c in pairs(floor.top.achild) do
-- U.dump(c, '?? for_child:'..k)
-- U.dump(basechild, '?? building_ang.for_child:'..k)
-- U.dump(c, '?? for_child:'..k)
-- U.dump(basechild, '?? building_ang.for_child:'..k)
-- base = c.base
end
-- U.dump(c.base, '?? child_ROT:'..k)
--[[
for j,f in pairs(d.afloor) do
-- U.dump(basechild, '?? fo_fch:'..i..':'..j)
-- local basechild = cedit.cval['DragVal'][ij[1]].achild[k]
-- _dbdrag = true
-- U.dump(desc.afloor[2].top, '?? post_rs:')
--[[
local ij = scope == 'floor' and {cij[1]} or cij
U.dump(ij, '?? fringe_io:'..tostring(scope))
forBuilding(desc, function(w, ij)
elseif key == 'fringe_height' then
-- U.dump(out.aedge, '?? fringe:')
forBuilding(desc, function(w, ij)
end
-- U.dump(desc.selection, '?? for_DSEL:')
local abase = {}
-- check consistency with top children
-- U.dump(c.base, '??^^^^^^^^^^^ for_child:'..j..':'..f)
-- U.dump(abase[f], '??^^^^^^^^^^^ for_fbase:'..j..':'..f)
-- U.dump(c.base, '??^^^^^^^^^^^ for_child:'..j..':'..f)
-- U.dump(abase[f], '??^^^^^^^^^^^ for_fbase:'..j..':'..f)
for a,isel in pairs(desc.selection[f]) do
-- if true then return end
-- U.dump(desc.selection, '?? wp:'..cij[1])
if desc.afloor[cij[1]].awplus then
if desc.afloor[cij[1]].awplus then
-- U.dump(desc.afloor[cij[1]].top.achild, '?? AW_children:')
for _,wp in pairs(desc.afloor[cij[1]].awplus) do
end
-- U.dump(desc.afloor[cij[1]].awplus, '?? AW_clean:')
end
-- [floor.top.cchild].dirty = true
-- U.dump(desc.selection,'?? to_pull2:'..tostring(desc.afloor[cij[1]].top.shape),true)
-- U.dump(desc.selection, '?? to_extr:'..val)
-- U.dump(desc.selection,'?? to_pull2:'..tostring(desc.afloor[cij[1]].top.shape),true)
-- U.dump(desc.selection, '?? to_extr:'..val)
-- indrag = false
elseif key == 'wall_spanx' then
U.dump(cij, '?? spanX:')
--TODO:
-- indrag = false
-- U.dump(desc.afloor[2].awall[3].df, '?? win_fitx:')
elseif key == 'win_u' then
if not tonumber(ij[2]) then
-- U.dump(desc.aspline,'?? win_bot:'..ij[2])
for _,d in pairs(desc.aspline[ij[1]][ij[2]].aforest) do
-- lo('??_______________ win_bottom:'..val..':'..winHeight..'/'..desc.afloor[ij[1]].h, true)
-- U.dump(ddae[w.win], '??_______________ win_bottom:'..val..':'..winHeigth..':'..desc.afloor[ij[1]].h)
--[[!!
if cedit.fscope == 1 then
-- U.dump(w['win'..'_inf'], '?? for_winf:'..tostring(cedit.forest)..':'..ij[1]..':'..ij[2])
-- U.dump(w.df, '?? for_winfDF:'..tostring(cedit.forest))
-- U.dump(w['win'..'_inf'], '?? for_winf:'..tostring(cedit.forest)..':'..ij[1]..':'..ij[2])
-- U.dump(w.df, '?? for_winfDF:'..tostring(cedit.forest))
-- lo('?? if_IND:'..dforest[cedit.forest].ind,true)
for j,k in pairs(w.df[dae]) do
-- U.dump(dforest[k], '?? in_dforest:'..j)
if k == cedit.forest then
]]
-- U.dump(w['win'..'_inf'], '?? post_set:')
else
if s then
-- U.dump(s, '?? ws_SPLINE:'..tostring(s.default)..':'..val)
if s.default then
if s.default then
-- U.dump(ddae[s.def['win'].dae], '?? dae_WIN:'..tostring(s.default))
s.def['win'].padding = val
elseif key == 'win_scale' then
U.dump(cij, '?? wscale:')
forBuilding(desc, function(w, ij)
if w.doorstairs and w.doorstairs[w.doorind] then
-- U.dump(w.doorstairs[w.doorind], '?? for_STAIRS:'..ij[1]..':'..ij[2])
w.doorstairs[val] = w.doorstairs[w.doorind]
@/lua/ge/extensions/career/modules/branches/landing.lua
local ret = {}
--dump("getting skills for " .. branchId)
for _, skill in pairs(career_branches.getSortedBranches()) do
for _, skill in pairs(career_branches.getSortedBranches()) do
--dump(branchId .. " is a skill of " .. skill.id.." / "..dumps( skill.parentId))
if skill.parentId == branchId then
@/lua/ge/extensions/gameplay/rally/recceApp.lua
-- if mission.startTrigger.level == level then
-- dump(mission.name .. ' ' .. mission.missionType)
-- end
@/lua/ge/extensions/gameplay/drag/dragBridge.lua
if current == nil then
log("E", logTag, "Property path not found: " .. dump(path))
return
if not found then
log("E", logTag, "Vehicle " .. model.model .. " does not match rule: " .. dump(rule.path))
return false
if propertyValue ~= rule.value then
log("E", logTag, "Vehicle " .. model.model .. " does not match rule: " .. dump(rule.path))
return false
@/ui/modules/lightrunner/lightrunner.js
//bngApi.engineLua(luaCmd)
// bngApi.engineLua("dump(" + bngApi.serializeToLua(track) + ")")
@/lua/ge/extensions/flowgraph/nodes/vehicle/ai/simpleFollowDecalroad.lua
veh:queueLuaCommand('ai.startFollowing(' .. serialize(self.path) .. ',nil,'..(self.pinIn.loopCount.value or -1)..',"'..self.data.loopMode..'")')
--dump('ai.startFollowing(' .. serialize(self.path) .. ',)')
self.running = true
@/lua/ge/extensions/flowgraph/nodes/gameplay/rally/setNoteSearch.lua
if self.pinIn.recoveredTo.value then
dump(self.pinIn.recoveredTo.value)
end
@/lua/ge/extensions/core/weather.lua
end
-- dump(tbl)
end
local function activate(presetName)
-- dump(presets)
local p = presets[presetName]
local function dumpWeatherPresets()
dump(presets)
end
@/lua/ge/extensions/core/settings/audio.lua
local record = split( v, '\t')
--dump(record)
local provider = record[1]
local providers = Engine.Audio.getInfo()
dump(providers)
log('I', '',' swapping to device index '..tostring(index))
if fmodDevices then
dump(fmodDevices[index])
createAudioDevice('FMOD', fmodDevices[index].name)
@/lua/vehicle/extensions/gameplayInterface.lua
print("gameplayInterface debug callback data:")
dump(data)
end
print(string.format("Can't find requested callback id %d", callbackId))
dump(callbacks)
return
@/lua/vehicle/controller/gauges/genericGauges.lua
--gcprobe()
--dump(gaugeData)
end
--dump(mergedConfig)
local configData = jbeamData.configuration or {}
--dump(configData)
for k, v in pairs(jbeamData) do
end
--dump(configData)
config = tableMerge(config, configData)
--dump(config)
@/lua/ge/extensions/editor/missionEditor/layers.lua
if add then
dump(add)
table.insert(self.mission.layers, add, addElem)
@/lua/ge/extensions/editor/forestView.lua
-- -- editor_forestEditor.selectForestItems(forestItems, addToSelection)
-- dump(editor_forestEditor.getVar())
-- else
@/lua/ge/extensions/util/trackBuilder/ceilingMesh.lua
--dump(minWidth .. " " ..shape.LUTMin .. " - " .. shape.LUTMax .. " " .. maxWidth)
@/lua/ge/extensions/flowgraph/nodes/math/math.lua
function C:onUnlink(link)
--dump(link.targetPin.name)
end
@/lua/ge/extensions/gameplay/rally/notebook/structured/visualCompositor.lua
-- dump(visualPacenotes)
@/lua/ge/extensions/core/quickAccess.lua
-- Restore previous game state
--dump("Hide: gameStateBefore")
--dump(gameStateBefore)
--dump("Hide: gameStateBefore")
--dump(gameStateBefore)
if gameStateBefore ~= nil then
local recent = getMostRecentAvailableActions("all", maxRecentActionsLimits.all)
dump("All")
for i, item in ipairs(recent) do
local actionInfo = getActionInfo(item.level, item.uniqueID)
dump(string.format("recent[%d] = %s %s (%d) (%s)", i, item.level, item.uniqueID, item.timestamp - Engine.Platform.getSystemTimeMS(), actionInfo and actionInfo.title or "MISSING"))
end
@/lua/vehicle/powertrain/genericTorqueProvider.lua
--dump(jbeamData)
@/ui/modules/busRoute/busRoute.js
//bngApi.engineLua(luaCmd)
// bngApi.engineLua("dump(" + bngApi.serializeToLua(route) + ")")
@/lua/ge/extensions/core/hotlapping.lua
info.justStarted = justStarted
--dump(info.justLapped)
if info.stop or info.justLapped or forceSendToGui then
--dump(tracks)
return tracks
@/lua/ge/extensions/flowgraph/nodes/vehicle/customPartsConfigProvider.lua
self.sortedKeys = keys
--dump(self.sortedKeys)
end
@/lua/ge/extensions/editor/gen/top.lua
local function chop(base)
-- U.dump(base, '>> cut:'..tostring(#base), true)
for i = 1,#base do
if ci == i then
-- U.dump(chunk, '?? chunk:')
break
if ci == U.mod(i+k,#base) then
-- U.dump(rest, '?? rest:')
return chunk,rest
local function forChunks(base)
-- U.dump(base,'>> forChunks:'..#base)
local achunk = {}
n = n + 1
-- U.dump(cbase, '?? for_N:'..n)
chunk,rest = chop(cbase)
chunk,rest = chop(cbase)
-- U.dump(chunk, '?? for_N_chunk:'..n)
dbase = {}
dbasepre = dbase
-- U.dump(cbase, '?? cBASE:')
-- U.dump(dbasepre, '?? dBASE:')
-- U.dump(cbase, '?? cBASE:')
-- U.dump(dbasepre, '?? dBASE:')
else
else
-- U.dump(dbasepre, '?? last:')
for i=1,#chunk do
-- table.insert(achunk, 1, chunk)
-- U.dump(achunk,'<< forChunks:'..#achunk)
return achunk
local achunk = forChunks(base)
-- U.dump(achunk, '??___________________ pave:')
local w = (base[2]-base[1]):cross(base[#base]-base[1]):normalized()
end
-- U.dump(av, '?? pave_BASE:')
auv = M.forUV(av, 1, uvini, (av[2]-av[1]):cross(av[3]-av[2]), uvscale or {1,1}) --, uvini, w, scale, auv)
end
-- U.dump(achunk, '<< pave:'..#av..':'..#af, true)
-- U.dump(af, '<< pave:'..#av..':'..#af)
-- U.dump(achunk, '<< pave:'..#av..':'..#af, true)
-- U.dump(af, '<< pave:'..#av..':'..#af)
return av,auv,af,{w}
local function pairsUp(base,ishift)
-- U.dump(base, '?? pairsUp:')
ishift = ishift or 0
local z = v1:cross(v2).z
-- U.dump(cmi,'?? to_check:'..z..':'..tostring(v1)..':'..tostring(v2))
if z < 0 then
end
-- U.dump(imi, '??+++++++++++ for_IMI:'..#U.index(ainpair,imi[1])..':'..#U.index(ainpair,imi[2]))
-- if imi then -- and #U.index(ainpair,imi[1])==0 then -- and #U.index(ainpair,imi[2])==0 then
end
-- U.dump(apair, '?? pairsUp_pairs:')
-- U.dump(amult, '?? pairsUp_muilt:')
-- U.dump(apair, '?? pairsUp_pairs:')
-- U.dump(amult, '?? pairsUp_muilt:')
return apair,amult
if dbg then
U.dump(base, '?? forGable:'..tostring(apair))
end
if not apair then
-- U.dump(base,'?? forGable:')
base = U.polyStraighten(base)
lo('!! ERR_forGable_MULT:'..tostring(apair)..':'..#base..':'..#U.polyStraighten(base)) --..':'..ang, true)
-- U.dump(base)
-- U.dump(mult,'!! ERR_forGable_MULT:')
-- U.dump(base)
-- U.dump(mult,'!! ERR_forGable_MULT:')
-- U.dump(pair,'!! ERR_forGable_PAIR:')
-- U.dump(mult,'!! ERR_forGable_MULT:')
-- U.dump(pair,'!! ERR_forGable_PAIR:')
-- U.dump(base,'!! ERR_forGable_BASE:')
-- U.dump(pair,'!! ERR_forGable_PAIR:')
-- U.dump(base,'!! ERR_forGable_BASE:')
return {}
end
-- U.dump(opair, '?? for_OPAIR:')
apair = opair
]]
-- U.dump(apair, '>> forGable:'..#base..':'..tostring(apair))
local function meshClose(pair, ap, aroof)
-- U.dump(pair, '?? meshClose:'..tostring(ap and #ap or nil))
if not ap then return end
-- U.dump(base, '?? to_CLOSE:'..#base)
an,auv,af = M.zip2(base,{1,2,5,4})
-- W.out.avedit = c
-- U.dump(a, '?? for_a:')
local ap,aP = stick(a,b,c, winv and D/d or d/D)
meshClose(apair[i], av, adata)
-- U.dump(av, '?? for_av_in:')
-- U.dump(av, '?? forGable.for_av2:'..tostring(av and #av or nil))
if not av then return {} end
meshClose(apair[#apair],av,adata)
-- U.dump(adata, '?? for_data:')
if dbg then
for i,d in pairs(adata) do
-- U.dump(d[1], '?? for_DATA:')
for k=2,#d.av,3 do
end
U.dump(base, '?? for_BASE:'..i)
W.out.avedit = {base[2],base[5]}
]]
-- U.dump(base, '>> forRidge:'..tostring(floor)..':'..(floor and floor.top.margin or 'NONE')..':'..tostring(flat)..':'..tostring(W))
if #base ~= 4 then flat = false end
local apair,amult = pairsUp(base,ishift)
-- U.dump(apair, '??+++++ APAIR:')
-- U.dump(amult, '??+++++ AMULT:')
-- U.dump(apair, '??+++++ APAIR:')
-- U.dump(amult, '??+++++ AMULT:')
for _,l in pairs(amult) do
if #list > 1 then
U.dump(list, '?? has_MULT:'..key)
-- find pairs in between
-- table.insert(apair,1,ch4)
-- U.dump(amult, '?? fR.for_MULT:')
-- U.dump(apair, '?? fR.forRidge.apair:'..tostring(floor))
-- U.dump(amult, '?? fR.for_MULT:')
-- U.dump(apair, '?? fR.forRidge.apair:'..tostring(floor))
--TODO: order pairs
local p = apair[j]
-- U.dump(p, '?? comp:'..i..':'..pair[1])
if pair[1] == U.mod(p[2]+1,#base) then
p[#p+1] = p1
-- U.dump(p, '>> flipped:'..j)
end
-- U.dump(apair, '??+++++ FIT:')
-- lo('??+++++ dist:'..(base[apair[1][1]]-base[apair[1][1]+1]):length())
-- for i = 1,#base do
-- U.dump(apair[cpair],'?? for_I:'..i..':'..cpair..':'..tostring(indown), true)
if indown then
if indown then
-- U.dump(cthread,'?? for_DOWN:'..i,true)
if #apair>0 and i == apair[cpair][2] then
if ischeck then return true end
-- U.dump(athread, '?? _aTHREAD:'..istart)
--[[
--[[
U.dump(apair, '?? forRidge.for_PAIRS:')
local cchunk = forChunks(cbase)
-- U.dump(cchunk, '?? for_CCHUNK:'..i)
for _,c in pairs(cchunk) do
end
-- U.dump(achunk, '??_________ ACHUNK:')
-- U.dump(archunk, '??_________ ARCHUNK:')
-- U.dump(achunk, '??_________ ACHUNK:')
-- U.dump(archunk, '??_________ ARCHUNK:')
local achunk = forChunks(base)
U.dump(achunk, '??_________ ACHUNK2:')
-- U.dump(achunk, '?? forRidge.achunk:')
U.dump(achunk, '??_________ ACHUNK2:')
-- U.dump(achunk, '?? forRidge.achunk:')
local noridge = {}
end
-- U.dump(base, '?? base:')
-- U.dump(af, '?? fR.for_AF:'..#af)
-- U.dump(base, '?? base:')
-- U.dump(af, '?? fR.for_AF:'..#af)
-- floor = {top = {margin = 0, mat = 'WM'}}
-- U.dump(athread, '?? for_THREAD:')
for _,t in pairs(athread) do
end
-- U.dump(cbase, '?? cbase:'.._)
achild[#achild+1] =
-- if iswrong then
-- U.dump(af, '?? for_AF:')
-- end
end
-- U.dump(achild, '?? fR.achild:'..tostring(flat))
floor.top.achild = achild
-- floor.top.achild[ichild] = achild[1]
-- U.dump(floor.top.achild[ichild], 'rU_ch:'..ichild)
-- end
desctop.shape = 'ridge'
-- if floor then U.dump(floor.top.achild, '?? aCHILD:') end
return true,{av=av,af=af,apair=apair}
-- if i == 6 then
U.dump(ps, '?? for61:'..tostring(ps[1]
U.dump(ps, '?? for61:'..tostring(ps[1]
-- U.dump(av, '?? for_AV:'..#av)
-- U.dump(auv, '?? for_AUV:'..#auv)
-- U.dump(av, '?? for_AV:'..#av)
-- U.dump(auv, '?? for_AUV:'..#auv)
-- U.dump(aft, '?? for_AF:'..#aft)
-- U.dump(auv, '?? for_AUV:'..#auv)
-- U.dump(aft, '?? for_AF:'..#aft)
-- af = aft
-- table.pack(1,2,3,4)
-- U.dump(noridge, '?? in_CHUNKS:'..#noridge)
-- U.dump(af, '?? for_AF:'..#base..':'..#af)
-- U.dump(noridge, '?? in_CHUNKS:'..#noridge)
-- U.dump(af, '?? for_AF:'..#base..':'..#af)
--[[
for key,_ in pairs(noridge) do
U.dump(achunk[key], '??***************** for_chunk:'..key)
local cbase = {}
for k,c in pairs(achunk) do
-- U.dump(c, '?? if_inchunk:'..p[1]..':'..p[2]..':'..#U.index(c,p[1]))
if #c == 4 and #U.index(c,p[1]) > 0 and #U.index(c,U.mod(p[1]+1,#base)) > 0 and #U.index(c,p[2]) > 0 and #U.index(c,U.mod(p[2]+1,#base)) > 0 then
if #c == 4 and #U.index(c,p[1]) > 0 and #U.index(c,U.mod(p[1]+1,#base)) > 0 and #U.index(c,p[2]) > 0 and #U.index(c,U.mod(p[2]+1,#base)) > 0 then
-- U.dump(p, '?? hit:'..k)
isin = true
baseext[#baseext+1] = c2
-- U.dump({p[1], U.mod(p[1]+1,#base), #baseext, #baseext-1}, '?? for_1st:')
-- U.dump({p[2], U.mod(p[2]+1,#base), #baseext-1, #baseext}, '?? for_2st:')
-- U.dump({p[1], U.mod(p[1]+1,#base), #baseext, #baseext-1}, '?? for_1st:')
-- U.dump({p[2], U.mod(p[2]+1,#base), #baseext-1, #baseext}, '?? for_2st:')
af = M.zip({p[1], U.mod(p[1]+1,#base), #baseext, #baseext-1}, af)
]]
-- U.dump(av, '?? av:'..#av)
-- return av,auv,af,aridge
end
U.dump(ajoin, '?? forRidge.ajoin:')
end
@/lua/ge/extensions/ui/liveryEditor/editor.lua
M.save = function(filename)
dump("save", filename)
if not hasLoadedFile and not filename then
M.applySkin = function()
dump("applySkin", skinName)
if hasLoadedFile and skinName then
if hasLoadedFile and skinName then
dump("applySkin applying skin", skinName)
core_vehicle_partmgmt.setSkin(skinName)
@/lua/ge/extensions/flowgraph/nodes/ui/updatedUI/startScreenDial.lua
self.panel.dials = {}
--dump(dragData)
if not dragData then
@/lua/ge/extensions/ui/liveryEditor/layers.lua
M.parseLayersData = function(layersData, parentLayer)
dump("parseLayerData", parentLayer)
local uiLayers = {}
M.dynamicDecals_onLayerAdded = function(layerUid)
dump("dynamicDecals_onLayerAdded", layerUid)
M.rebuildLayerData()
M.dynamicDecals_onLayerDeleted = function(layerUid)
dump("dynamicDecals_onLayerDeleted", layerUid)
M.rebuildLayerData()
M.dynamicDecals_onLayerUpdated = function(layerUid)
dump("dynamicDecals_onLayerUpdated", layerUid)
M.rebuildLayerData()
M.dynamicDecals_moveLayer = function(from, fromParentUid, to, toParentUid)
dump("dynamicDecals_moveLayer",
"from: " .. from .. ", fromParent: " .. (fromParentUid or "nil") .. ", to: " .. to .. ", toParent: " ..
@/lua/ge/extensions/editor/missionPlaybook/missionTreeViewer.lua
if (bit.band(tonumber(ui_flowgraph_editor.GetDirtyReason()), ui_flowgraph_editor.Dirty_Position) ~= 0) then
dump("AD")
ui_flowgraph_editor.ClearDirty()
resultData.unlocksById = unlocksById
dump(resultData.unlockedThisStep)
@/lua/ge/extensions/editor/rallyEditor/notebookInfo.lua
local codriverName = codriver.name
-- dump(codriver.id)
-- dump(self.path:selectedCodriver().id)
-- dump(codriver.id)
-- dump(self.path:selectedCodriver().id)
-- dump('-------------------------')
-- dump(self.path:selectedCodriver().id)
-- dump('-------------------------')
if codriver.id == self.path:selectedCodriver().id then
@/lua/ge/extensions/core/vehicleTriggers.lua
if lnk.version and lnk.version == 2 then
--dump({'>>>>> executeLink', lnk.inputAction, actionValue, vehicleId})
@/lua/vehicle/powertrain/electricMotor.lua
device.engineVolumeCoef = 1
--dump(sounds)
sounds.disableOldEngineSounds()
}
--dump(params)
end
--dump(sounds)
sounds.disableOldEngineSounds()
--dump(jbeamData)
@/lua/vehicle/controller/advancedCouplerControl.lua
local function onCouplerFound(nodeId, obj2id, obj2nodeId)
--dump(couplerGroup)
end
--print(M.name)
--dump(jbeamData)
@/lua/vehicle/controller/pneumatics.lua
local pressureBeamSoundData = v.data[jbeamData.groupSounds] or {}
--dump(pressureBeamSoundData)
--dump(beamGroups)
end
@/lua/ge/extensions/gameplay/rally/test/testRouteFix.lua
if im.IsMouseClicked(0) then
dump(mousePos)
end
@/lua/objectpool/main.lua
function onNodeCollision(id1, pos, normal, nodeVel, perpendicularVel, slipVec, slipVel, slipForce, normalForce, depth, materialId1, materialId2)
--dump({"Node collision with object:", obj:getId(), counter})
end
@/lua/common/controlSystems.lua
function PIDParallel:dump()
print(string.format("PID Parallel: kP: %.2f, kI: %.2f, kD: %.2f, Min: %.2f, Max: %.2f, Min Integral %.2f, Max Integral: %.2f", self.kP, self.kI, self.kD, self.minOutput, self.maxOutput, self.minIntegral, self.maxIntegral))
function PIDStandard:dump()
print(string.format("PID Standard: kP: %.2f, kI: %.2f, kD: %.2f, Min: %.2f, Max: %.2f, Min Integral %.2f, Max Integral: %.2f", self.kP, self.kI, self.kD, self.minOutput, self.maxOutput, self.minIntegral, self.maxIntegral))
@/lua/ge/extensions/editor/shapeEditor.lua
local function _writeMeshConstructor()
dump(path.split(meshFile))
local path,filename,ext = path.split(meshFile)
@/lua/ge/extensions/flowgraph/nodes/ui/vehicleSelector.lua
data.callObj = 'core_flowgraphManager.getManagerGraphNode('..self.mgr.id..', '..self.graph.id..', '..self.id..')'
dump("THIS IS THE CALL OBJ")
dump(data.callObj)
dump("THIS IS THE CALL OBJ")
dump(data.callObj)
data.readyHook = data.callObj .. ':started()'
@/lua/ge/extensions/editor/gen/utils.lua
-- U.out.aset[6] = {set={p}}
-- U.dump(line, '>> angDistSeg:'..tostring(d)..':'..tostring(p))
return angDist(p,b)
local function dump(t, msg, lvl, lvlma)
-- print('>> dump:'..tostring(lvlma))
-- lo(type(o)..':'..type(e)..':'..o..':'..tostring(e))
local lt = U.dump(e, nil, lvl+1, lvlma)
-- lo('?? dret:'..lt)
local d = intersectsRay_Plane(line[1], line[2]-line[1], p[1], (p[2]-p[1]):cross(p[3]-p[1]))
-- U.dump(p, '?? linePlaneHit:'..d..':'..tostring(line[1])..':'..tostring(line[2]), true)
if d < mi then mi = d end
a = U.proj2D(a)
-- U.dump(base, '>> polyCross:'..tostring(a)..':'..tostring(dir:normalized()))
local ahit = {}
end
-- U.dump(ahit, '??++++++++++++++++++++ polyCross:')
local mileft,miright = math.huge,math.huge
U.polyCut = function(base, pfr, pto)
-- U.dump(base, '?? polyCut_base:'..#base)
-- U.dump(pfr, '?? polyCut_fr:')
-- U.dump(base, '?? polyCut_base:'..#base)
-- U.dump(pfr, '?? polyCut_fr:')
-- U.dump(pto, '?? polyCut_to:')
-- U.dump(pfr, '?? polyCut_fr:')
-- U.dump(pto, '?? polyCut_to:')
if not pfr then return end
local map
-- U.dump(imap, '?? CUT12_m:')
-- U.dump(b12, '?? CUT12_b:')
-- U.dump(imap, '?? CUT12_m:')
-- U.dump(b12, '?? CUT12_b:')
b12,map = U.polyStraighten(b12)
b12,map = U.polyStraighten(b12)
-- U.dump(b12, '?? CUT12_b_post:')
-- U.dump(map, '?? CUT12_m_post:')
-- U.dump(b12, '?? CUT12_b_post:')
-- U.dump(map, '?? CUT12_m_post:')
local imap12 = {}
end
-- U.dump(imap12, '?? map12:')
end
-- U.dump(imap, '?? CUT21_m:')
-- U.dump(b21, '?? CUT21_b:')
-- U.dump(imap, '?? CUT21_m:')
-- U.dump(b21, '?? CUT21_b:')
b21,map = U.polyStraighten(b21)
b21,map = U.polyStraighten(b21)
-- U.dump(b21, '?? CUT21_b_post:')
-- U.dump(map, '?? CUT21_m_post:')
-- U.dump(b21, '?? CUT21_b_post:')
-- U.dump(map, '?? CUT21_m_post:')
local imap21 = {}
end
-- U.dump(imap21, '?? map21:')
return {b12, b21}, {imap12,imap21}
local list,map = U.polyStraighten(b12)
U.dump(b12, '?? CUT12_b_post:')
U.dump(map, '?? CUT12_m_post:')
U.dump(b12, '?? CUT12_b_post:')
U.dump(map, '?? CUT12_m_post:')
-- U.dump(U.polyStraighten(b12))
U.dump(map, '?? CUT12_m_post:')
-- U.dump(U.polyStraighten(b12))
U.dump(b21, '?? CUT21:')
-- U.dump(U.polyStraighten(b12))
U.dump(b21, '?? CUT21:')
-- U.dump(U.polyStraighten(b21, true))
U.dump(b21, '?? CUT21:')
-- U.dump(U.polyStraighten(b21, true))
U.polyStraighten(b12)
-- if true then return end
-- dump(apatch, '>> rcPave:'..#aloop)
-- dump(rc, '>> rcPave_hull:')
-- dump(apatch, '>> rcPave:'..#aloop)
-- dump(rc, '>> rcPave_hull:')
indrag = true
lo('>>************ forCross:'..tostring(v), true)
-- U.dump(vinfo, '>>************ forCross:'..tostring(v)..':'..#v4e)
end
end
-- if dbg then U.dump(e4v[i], '?? for_E:'..i..':'..tostring(c)) end
-- if dbg then lo('?? for_E:'..i..':'..e4v[i][1].ind..':'..e4v[i][2].ind..':'..tostring(c), true) end
if dbg and c then
-- U.dump(e4v[i], '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e, '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e4v[i], '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e, '??+++ for_e:'..i..':'..tostring(c))
end
if d == 0 then
if istest then U.dump(e4v[i],'?? on_EDGE:'..i) end
isdupe = true
isend = e4v[i][1].ind
if dbg then U.dump(e4v[i], '??_____________ END1:'..isend) end
elseif (e[2] - cmi):length() < sense then
isend = e4v[i][#e4v[i]].ind
if dbg then U.dump(e4v[i], '??_____________ END2:'..isend) end
else
if isdupe then
if istest then U.dump(e4v[imi], '??__________________ DUPE:'..tostring(cmi)..':'..tostring(imi)) end
v4e[k].isdupe = true
local d = (cmi-ae[imi][1]):length()/(ae[imi][2]-ae[imi][1]):length()
-- U.dump(e4v[imi], '?? v:'..k..' to:'..tostring(d))
e4v[imi][#e4v[imi]+1] = {ind = k, d = d, done = 0}
v4e[k][#v4e[k]+1] = imi
-- U.dump(v4e[k], '?? v___:'..k..' to:'..tostring(d)..':'..imi)
elseif imi then
elseif imi then
-- U.dump(ae[imi], '?? for_cross: k='..k..' ie:'..imi..':'..tostring(p))
-- edges connecting loops
if isend then
-- U.dump(e4v[#e4v], '??********************* new_e4v:'..#v4e..':'..tostring(isend))
end
end
-- if istest then U.dump(e4v, '?? e4v:') end
if istest then U.dump(v4e, '?? v4e:'..nv) end
-- if istest then U.dump(e4v, '?? e4v:') end
if istest then U.dump(v4e, '?? v4e:'..nv) end
if istest then U.dump(ae, '?? ae:') end
if istest then U.dump(v4e, '?? v4e:'..nv) end
if istest then U.dump(ae, '?? ae:') end
local albl = {}
end
-- U.dump(v4e, '?? av:'..nv)
-- U.dump(estamp, '?? estamp:'..nv)
-- U.dump(v4e, '?? av:'..nv)
-- U.dump(estamp, '?? estamp:'..nv)
-- if true and istest then return {},{},ae,{},albl end
local dbg = false --(n1 == 15 and n2 == 4)
if dbg then U.dump(v4e[n2], '>>__________________________ stepFrom:'..n1..'>'..n2..'/'..ns) end
local astar = {}
for _,ie in ipairs(v4e[n2]) do
if dbg then U.dump(e4v[ie], '??***** for_edge:'..ie) end
for i,n in ipairs(e4v[ie]) do
end
if istest and dbg then U.dump(astar, '?? star:') end
local v = v4e[n2].p - v4e[n1].p
end
-- U.dump(ima, '<< stepFrom:'..tostring(ima[1].ind))
if ima then
togo = true
-- if istest then U.dump(list, '?? step:'..n.ind..':'..n.d) end
local iprev, inext = n.ind, n.d < 1 and list[k+1].ind or list[k-1].ind
end
if istest then U.dump(rc, '??<<<<<<< for_rc:') end
if #rc > 2 then
end
if istest then U.dump(arc, '?? arc:'..#arc..':'..ns) end
--!! table.remove(arc, #arc)
local rc = arc[k]
-- U.dump(rc, '?? for_rc:')
local ifirst
end
-- U.dump(rc, '?? shifted:'..k)
end
end
-- U.dump(rc, '?? cleaned:'..k)
end
end
--U.dump(ast, '??___________________ ast:')
end
-- U.dump(v4e, '?? for_RC:'..#arc)
if istest then U.dump(arc, '?? cleaned:'..#arc..':'..stbase) end
-- U.dump(v4e, '?? for_RC:'..#arc)
if istest then U.dump(arc, '?? cleaned:'..#arc..':'..stbase) end
apath = {}
apath = {}
-- U.dump(arc, '?? cleaned:'..#arc..':'..stbase)
-- if true then return {},{},ae,apath,albl end
-- U.dump(ast, '?? ast:')
-- local u,v = rc[2]-rc[1],rc[4]-rc[1]
end
-- U.dump(af, '?? AF:'..#af)
-- U.dump(e4v, '?? e4v:')
-- U.dump(apath, '?? apath:')
-- U.dump(e4v, '?? e4v:')
-- U.dump(apath, '?? apath:')
-- lo('<< rcPave: av:'..#av..' af:'..#af..' afhole:'..#afhole..'/'..ns, true)
--
U.dump(e4v[v4e[k][3] ], '?? for_v:'..k..' e:'..v4e[k][3])
local rc = {v4e[k].p}
local av = e4v[ie] --
-- U.dump(av, '?? sorted:')
local iv = av[U.index(av, k, 'ind')[1]+1] -- index of next node
local vlist = e4v[e]
U.dump(vlist, '?? for_VLIST:'..j..':'..iv..':'..tostring(rc[#rc]))
local ind = index(vlist, iv, 'ind')[1]
end
U.dump(adir, '?? for_DIR:'..k..':'..tostring(iv))
break
-- for j,av in ipairs(vlist) do
-- U.dump(,'?? for_vlist:')
-- end
end
U.dump(rc, '?? for_rc:')
arc[#arc+1] = rc
end
-- U.dump(ae, '<< rcPave:'..#out)
return ae
if l.ind == k then
U.dump(av[i+1], '?? nxt:'..k)
rc[#rc+1] = v4e[av[i+1].ind].p
-- next step
U.dump(v4e[inext], '?? for_next:'..inext)
--- build star
for _,ie in ipairs(v4e[inext]) do
U.dump(e4v[ie], '?? for_edge:'..ie)
local edge = e4v[ie]
-- for _,
-- U.dump(ae[ie], '?? for_edge:'..ie)
-- local v =
for i,pth in pairs(aeref) do
-- dump(pth, '?? for_pth:'..i..'/'..#aloop)
for j=2,#pth do
end
dump(ae[imi], '?? segNear:'..tostring(push)..':'..tostring(p)..'>'..tostring(cmi)..':'..#ae)
end
for i,loop in pairs(aloop) do
dump(loop, '?? for_loop:'..i..'/'..#loop)
for j,p in pairs(loop) do
local function segNear_(p, ae, axis, dir)
-- U.dump(ae, '?? AE:')
local fr,to = 1,#ae
end
U.dump(ae[imi], '?? segNear:'..p[1]..':'..p[2])
end
end)
dump(aex, '?? AEX:')
dump(aey, '?? AEY:')
dump(aex, '?? AEX:')
dump(aey, '?? AEY:')
local ax = U.clone(aex)
for i,e in pairs(aex) do
U.dump(e, '??======================== for_E_VERT:'..i)
if e[4] == 1 then
local function forStar(astem, ard)
-- U.dump(astem, '>> forStar:')
-- if not ard then ard = adec end
-- aang[#aang + 1] = {i, math.atan2(v.y, v.x) % (2*math.pi)}
-- U.dump(aflag, '<< forStar:')
return aflag
local aspline = U.circSpline(base)
-- U.dump(aspline, '?? path2spline:'..#base)
-- lift edges to splne
ap[#ap+1] = base[#base]
-- U.dump(ap, '?? for_AP:'..#ap)
-- out.avedit = ap
local function paraSpline(ap)
-- U.dump(ap, '>> paraSpline:'..#ap)
local apar = {}
d1 = p:distanceToLine(rc[1],rc[2]) + p:distanceToLine(rc[3],rc[4]) - rc[1]:distanceToLine(rc[3],rc[4])
-- dump(rc, '?? for_rc1:'..i..' d:'..d1..':'..tostring(p:distanceToLine(rc[1],rc[2]))..':'..tostring(p:distanceToLine(rc[3],rc[4]))..':'..tostring(rc[1]:distanceToLine(rc[3],rc[4])))
if p:distanceToLine(rc[1],rc[2]) + p:distanceToLine(rc[3],rc[4]) < rc[1]:distanceToLine(rc[3],rc[4]) + miss then
d2 = p:distanceToLine(rc[2],rc[3]) + p:distanceToLine(rc[4],rc[1]) - rc[1]:distanceToLine(rc[2],rc[3])
-- dump(rc, '?? for_rc2:'..i..' d:'..d2..':'..tostring(p:distanceToLine(rc[2],rc[3]))..':'..tostring(p:distanceToLine(rc[4],rc[1]))..':'..tostring(rc[1]:distanceToLine(rc[2],rc[3])))
if p:distanceToLine(rc[2],rc[3]) + p:distanceToLine(rc[4],rc[1]) < rc[1]:distanceToLine(rc[2],rc[3]) + miss then
end
-- U.dump(mbase, '<< polyMargin:')
return mbase
@/lua/ge/extensions/freeroam/bigMapMode.lua
local function setOnlyIdsVisible(list)
dump("Set only ids visible: " .. #list)
currentlyVisibleIds = list or {}
@/lua/vehicle/controller.lua
table.insert(stateEvents, {...})
dump(stateEvents)
end
@/lua/ge/extensions/util/dependencyTree.lua
--dump(entities)
jsonWriteFile('dependencytree.json', entities, true)
@/lua/common/extensions.lua
-- This is performance sensitive, please disable transient debug code
-- dump("Extension Hook: " .. funcName .. " : " .. dumps(... or {}))
local funcList = luaExtensionFuncs[funcName]
-- This is performance sensitive, please disable transient debug code
-- dump("Extension Hook: " .. funcName .. " : " .. dumps(... or {}))
local funcList = luaExtensionFuncs[funcName]
if completedList then
-- dump(completedList)
for i = 1, #completedList do
@/lua/vehicle/extensions/scenario/annotate.lua
end
dump(data)
end
@/lua/ge/extensions/ui/extApp.lua
for _, evt in ipairs(events) do
--dump({"event: ", evt})
if evt.type == 'D' and evt.msg ~= '' then
@/lua/common/jbeam/sections/vropes.lua
for ropeName, ropeConfig in pairs(vehicle.vropes) do
--dump({"ropeName", ropeName, "ropeConfig", ropeConfig})
if ropeConfig and ropeConfig.anchorAProp and ropeConfig.anchorBProp then
--dump({"ropeConfig.anchorAProp", ropeConfig.anchorAProp, "ropeConfig.anchorBProp", ropeConfig.anchorBProp})
-- Get anchor node positions
@/lua/vehicle/backwardsCompatibility.lua
-- please do not commit this, only enable in local builds
--dump(compatDiffs)
return compatDiffs
v.data.energyStorage = v.data.energyStorage or {}
dump("Used backwardsCompatibility")
local fuelTank = {name = "fuelTank", type = "fuelTank", fuelCapacity = v.data.engine.fuelCapacity, fuel = v.data.engine.fuel}
--dump(v.data.powertrain)
@/lua/ge/extensions/util/stepHandler.lua
M.onVehicleGroupSpawned = function(vehIds, groupId)
--dump(vehIds, groupId)
--dump(taskData.steps[taskData.currentStep])
--dump(vehIds, groupId)
--dump(taskData.steps[taskData.currentStep])
if not taskData.active or not taskData.steps[taskData.currentStep] or not taskData.steps[taskData.currentStep].waitForVehicleGroup then
log("E","","This step timed out ("..(stepToHandle.timeout or 120).."s). Step will be set to complete. Origin: "..dumps(descriptor))
dump(stepToHandle)
stepToHandle.complete = true
@/lua/ge/extensions/gameplay/missions/missionScreen.lua
if gameplay_missions_missionManager.getForegroundMissionId() == m.id then
--dump("default user settings from ",info.defaultUserSettings)
--info.defaultUserSettings = deepcopy(m.lastUserSettings or {})
--info.defaultUserSettings = deepcopy(m.lastUserSettings or {})
--dump(info.defaultUserSettings)
--info.activeStars = M.getActiveStarsForUserSettings(m.id, info.defaultUserSettings)
for key, prog in pairs(info.formattedProgress.formattedProgressByKey) do
--dump(key)
--dumpz(prog, 5)
if not same then
--dump(defaultUserSettings)
--dump(flatSettings)
--dump(defaultUserSettings)
--dump(flatSettings)
end
for key, prog in pairs(formattedProgress.formattedProgressByKey) do
--dump(key)
--dumpz(prog, 5)
end
--dump(formattedProgress.formattedProgressByKey[progressKey])
--dump("missionProgressKeyChanged", progressKey, translation)
--dump(formattedProgress.formattedProgressByKey[progressKey])
--dump("missionProgressKeyChanged", progressKey, translation)
guihooks.trigger('missionProgressKeyChanged', {
@/lua/ge/extensions/flowgraph/nodes/tech/getUltrasonicReadings.lua
local data = extensions.tech_sensors.getUltrasonicReadings(self.pinIn.sensorId.value)
dump(data)
end
@/lua/ge/extensions/trackbuilder/trackBuilder.lua
if im.InputInt("Index", subTrackIndex) then
--dump("Switched subtrack to: " .. subTrackIndex[0])
tbFunctions.switchSubTrack(subTrackIndex[0])
local indexes = tb.getSegmentInfo(segIndex).procObstacleIndexes
--dump(obstacles)
--dump(procObstacleIndexes)
--dump(obstacles)
--dump(procObstacleIndexes)
local pipette = im.GetIO().KeyShift and not im.GetIO().KeyCtrl and im.IsMouseClicked(0,false)
--dump(res)
if (doFill or holdAndPaint or pipette) and res.object then
local txt = '[' .. tostring(res.object:getId()) .. ']'
--dump(txt)
--dump(res.object:getName())
--dump(txt)
--dump(res.object:getName())
local index, sub = meshNameToIndex(res.object:getName())
local piece = tb.getSelectedTrackInfo()
--dump(piece)
local info = piece.parameters
@/lua/ge/extensions/scenario/scenarios.lua
-- log('I', logTag, 'saveStats called.....')
-- dump(stats)
end
--dump(scenario.vehicleTrackingTable)
end
-- dump(scenario.pooledResults)
for i, result in ipairs(scenario.pooledResults) do
inputActionFilter.addAction(0, action, true)
dump(scenario.blackListActions)
end
-- dump(data)
return data
-- log('D', logTag, 'onDeserialized called...')
-- dump(data)
if not data.sourceFile then return end
newScenario.startingTransforms = data.startingTransforms
-- dump(newScenario)
-- log('I',logTag, 'updateVehicleAiState called...'..tostring(vehicleName))
-- dump(data)
-- log('I',logTag, 'onBeamNGTrigger called...')
-- dump(data)
if not scenario then
@/lua/vehicle/extensions/gameplayInterfaceModules/interactCargoContainers.lua
functionCache[expr].result = functionCache[expr].fun()
--dump(expr, functionCache[expr].result)
end
obj:setNodeMass(node.cid, nodeWeight)
--dump("setNodeMass To ", node.cid, nodeWeight)
end
local beamDamp = beam.beamDamp
--dump("setBeamSpringDamp From", beam.cid, beamSpring, beamDamp)
obj:setBeamSpringDamp(beam.cid, beamSpring, beamDamp, -1, -1)
--dump("setBeamSpringDamp To ", beam.cid, beamSpring, beamDamp)
end
local beamLimitDamp = -1
--dump("setBeamSpringDamp From", beam.cid, beamSpring, beamDamp)
if beam.beamLimitSpringFunction then
obj:setBoundedBeamSpringDampLimits(beamId, beamLimitSpring, beamLimitDamp, -1)
--dump("setBeamSpringDamp To ", beam.cid, beamSpring, beamDamp)
end
obj:setBeamStrength(beam.cid, beamStrength)
--dump("setBeamStrength To ", beam.cid, beamStrength)
end
obj:setBeamDeform(beam.cid, beamDeform)
--dump("beamDeform To ", beam.cid, beamDeform)
end
obj:setBoundedBeamShortBound(beam.cid, beamShortBound)
--dump("setBoundedBeamShortBound To ", beam.cid, beamShortBound)
end
obj:setBoundedBeamLongBound(beam.cid, beamLongBound)
--dump("setBoundedBeamLongBound To ", beam.cid, beamLongBound)
end
--dump(cargoContainerById)
end
@/lua/ge/extensions/editor/dynamicDecals/layerStack.lua
if im.Button(string.format("dump##%s", layer.uid)) then
dump(layer)
end
if im.Button(string.format("Dump##%s_%s_%s_%d", layer.uid, guiId, "layerMaskLayerDumbButton", k)) then
dump(maskLayer)
end
@/lua/ge/extensions/core/input/bindings.lua
--dump({"enabledActionsMap: ", enabledActionsMap})
end
@/lua/ge/extensions/editor/dynamicDecals/layerTypes/linkedSet.lua
local property = layer.properties[id]
-- dump(property)
if editor.uiIconImageButton(editor.icons.delete, tool.getIconSizeVec2(), nil, nil, nil, string.format("PropertiesRemoveButton_%s_%s_%s", guiId, layer.uid, property.id)) then
@/lua/ge/extensions/flowgraph/nodes/mission/knockAwayCheck.lua
end
--dump(resetData)
local change, changed = {}, false
@/lua/ge/extensions/editor/gen/network.lua
--lo('??************** for_TB:'..tostring(tb:getObjectBox():getExtents()))
--U.dump(tb:getObjectBox():getExtents(), '??********** for_TB:')
--local groupEdit = scenetree.findObject('edit')
-- print('?? sf3:'..snew..':'..edges.infaces[snew])
-- U.dump(edges.infaces, '?? Infaces:'..stamp)
-- print('?? FOR_2:'..tostring(ang)..':'..tostring(anode[#anode].pos)..':'..tostring(anode[#anode].ang))
-- U.dump(anode[#anode], '?? FOR_2:'..tostring(ang))
edges.astamp[#edges.astamp + 1] = U.stamp({1, 2})
-- U.dump(anode[1], '?? node1:')
-- U.dump(anode[2], '?? node2:')
-- U.dump(anode[1], '?? node1:')
-- U.dump(anode[2], '?? node2:')
print('!! NO_PAIRS:'..i..'/'..nnode..':'..#anode)
U.dump(edges.astamp)
U.dump(edges.infaces)
U.dump(edges.astamp)
U.dump(edges.infaces)
return
-- U.dump(anode[#anode], '?? node:'..i)
end
end
U.dump(anode, '?? anode:'..tostring(massCenter))
U.dump(edges.astamp)
U.dump(anode, '?? anode:'..tostring(massCenter))
U.dump(edges.astamp)
Net.out.inseed = true
jointpath[#jointpath + 1] = 0
-- U.dump(path, '?? path:'..#apath)
end
--- find free nodes
-- U.dump(jointpath, '?? JPATH:')
-- U.dump(U.index(jointpath, 7), '?? i_7:')
-- U.dump(jointpath, '?? JPATH:')
-- U.dump(U.index(jointpath, 7), '?? i_7:')
local afree = forOdd()
path = { afree[1] }
U.dump(afree, '?? afree:')
U.dump(apath[#apath], '?? path:'..path[1])
U.dump(afree, '?? afree:')
U.dump(apath[#apath], '?? path:'..path[1])
-- path = { afree[math.random(#afree)] }
if #afree > 0 then
U.dump(afree, '?? MORE:')
--TODO: increase nmax
-- apath[#apath + 1] = path
U.dump(anode, '<< pathsUp:'..#jointpath..'/'..#anode..':'..#apath)
U.dump(apath, '?? JP:')
U.dump(anode, '<< pathsUp:'..#jointpath..'/'..#anode..':'..#apath)
U.dump(apath, '?? JP:')
end
local path = rd.path
U.dump(path)
local newRoadID = editor.createRoad(
end
U.dump(dec2path, '?? DEC2PATH:')
rd.dec2path = dec2path
-- U.dump(aang, '<< linkOrder:'..angp)
return aang
for key,list in pairs(dlist) do
-- U.dump(list, '?? ani_LIST:'..key..':'..#list)
if n <= #list then
local path = rd.path
U.dump(path)
local newRoadID = editor.createRoad(
-- local acnode = editor.getNodes(road)
-- U.dump(dec2path, '?? DEC2PATH:'..tostring(nedge)..':'..#acnode)
local aseg = {}
local cedge = 0
-- U.dump(nodelist, '?? NLIST:'..#nodelist)
for k,n in pairs(nodelist) do
road:delete()
-- U.dump(aseg, '?? ASEG:'..#aseg)
local ani = {}
for i,s in pairs(aseg) do
-- U.dump(s, '?? for_seg:'..i)
newRoadID = editor.createRoad(
an[#an+1] = s[#s-2]
-- U.dump(an, '?? AN:')
for k = 1,#s do
-- U.dump(s[k], '?? for_node:')
editor.addRoadNode(newRoadID, {
end
-- U.dump(ani, '?? for_ANI:')
local nma = 0
-- inanim = {ain = ani, cb = roadAni, n = 0, N = nma}
-- U.dump(inanim, '?? for_ANI:')
return
end
-- U.dump(pth, '?? pre_lev:'..tostring(ib)..':'..tostring(ie))
for o = ib,ie,dir do
-- print('?? for_star:'..sc..':'..#star)
-- U.dump(star)
-- get co-direction
--- pick opposite branch
-- U.dump(aang, '?? aang:')
local imi
if ialt ~= nil then
U.dump(aang, '??********** FOR_SC:'..sc..':'..aang[imi][1]..'>'..aang[ialt][1])
end
-- U.dump(dec, '?? dec:')
-- U.dump(astamp, '<< stem:')
-- U.dump(dec, '?? dec:')
-- U.dump(astamp, '<< stem:')
return dec
if dbg == true then
U.dump(road.apin, '?? mesh_apin:'..nsec)
end
local levels = levelsUp(dec, #list2 - 1)
U.dump(levels, '?? LEVELS:'..#dec)
roads[#roads + 1] = {
local hmap, apin = {}, {}
-- U.dump(levels, '?? LEV:')
-- U.dump(r.dec2path, '?? dec2path:'..nsec)
-- U.dump(levels, '?? LEV:')
-- U.dump(r.dec2path, '?? dec2path:'..nsec)
local cdec = 1
r.apin = apin
-- U.dump(r, '?? for_road:')
-- print('?? PRE_UP: nsec='..nsec..' adec='..#adec..':'..tostring(rd)..'::'..#hmap..'::'..tostring(#r.apin))
-- U.dump(hmap, '?? hmap:')
-- U.dump(r.apin, '?? apin:')
-- U.dump(hmap, '?? hmap:')
-- U.dump(r.apin, '?? apin:')
local id = decalUpdate(rd, hmap, r.apin) --, true)
end
U.dump(dec, '<< toDecals:'..#roads)
end
local inpath = U.index(r.path, icirc)
-- U.dump(inpath, '?? inpath:'..i)
-- U.dump(r.apin, '?? r:'..i)
-- U.dump(inpath, '?? inpath:'..i)
-- U.dump(r.apin, '?? r:'..i)
for _,j in pairs(inpath) do
end
U.dump(inedge, '?? inedge')
-- get star of vectors
end
U.dump(adir, '?? adir:')
local aang = U.fanOrder(adir)
local aang = U.fanOrder(adir)
U.dump(aang, '?? aang:')
-- for o = 3,3 do
-- U.dump(hpin,'?? hpin:')
local hmap, apin = av2hmap(edec, hpin)
local hmap, apin = av2hmap(edec, hpin)
U.dump(hmap,'?? hmap_PRE:')
U.dump(apin,'?? apin_PRE:')
U.dump(hmap,'?? hmap_PRE:')
U.dump(apin,'?? apin_PRE:')
--- mesh
@/lua/ge/extensions/flowgraph/nodes/gameplay/race/raceMarkers.lua
end
--dump(wps)
self.markers.setModes(wps)
@/lua/ge/extensions/flowgraph/modules/cameraModule.lua
local id = self:getFreeId()
--dump(path)
self.storedPaths[id] = path
@/lua/ge/extensions/util/trackBuilder/splineTrack.lua
else
--dump(scenetree.findObject("thePlayer"))
--dump(scenetree.findObject("thePlayer"):getID())
--dump(scenetree.findObject("thePlayer"))
--dump(scenetree.findObject("thePlayer"):getID())
--dump(getObjectByID(scenetree.findObject("thePlayer"):getID()))
--dump(scenetree.findObject("thePlayer"):getID())
--dump(getObjectByID(scenetree.findObject("thePlayer"):getID()))
local id = scenetree.findObject("thePlayer"):getID()
if index == #subTracks[subTrackIndex] then
--dump("isLast")
pieces[#subTracks[subTrackIndex]].invalid = true
if pieces[index][name] ~= nil then
--dump(pieces[index][name])
M.invalidatePiece(index, name)
else
--dump("all")
local existingMarkers = {}
local function save(filename, saveOptions)
--dump(saveOptions)
local date = os.date("*t")
local read = loadJSON(name)
--dump(name)
--dump(read)
--dump(name)
--dump(read)
if read then
if read.version == nil then
--dump(read)
log('I', logTag, "The file 'trackEditor/"..name..".json' uses an old format that is no longer supported.")
@/lua/vehicle/controller/couplings/kingpin.lua
]], controllerName, objectId, serialize(data))
--dump(fifthwheelCmd)
obj:queueObjectLuaCommand(objId, fifthwheelCmd)
@/lua/vehicle/extensions/escMeasurement.lua
--print(string.format("%.2f -> %.2f, %.3f -> %.2f", bsa, speedPoint, wheelAnglePoint, yawRatePoint))
--dump(measurementsSTM)
end
@/lua/ge/extensions/util/jbeamStats.lua
-- dump(extensions.util_jbeamStats.getStats())
@/lua/ge/extensions/util/trackBuilder/multiTrackMerger.lua
end
--dump(#meshes[1])
splineObject:registerObject(name)
@/lua/vehicle/controller/drivingDynamics/CMU.lua
if data then
--dump(data)
local splits = split(data, "->")
local configTable = jsonDecode(controllerConfig, "CMU SetConfig")
--dump(configTable)
receiver.setConfig(configTable)
local paramTable = jsonDecode(param, "CMU SetProperty")
--dump(paramTable)
receiver.setParameters(paramTable)
log("D", "CMU.applyParameter", "Can't find parameter: " .. name)
-- dump(changedParameters)
-- dump(currentControlParam)
-- dump(changedParameters)
-- dump(currentControlParam)
-- dump(currentDefaultControlParam)
-- dump(currentControlParam)
-- dump(currentDefaultControlParam)
-- print(debug.traceback())
@/lua/ge/extensions/gameplay/statistic.lua
-- log("E","startAct", dump(currentActivity))
end
@/lua/ge/extensions/gameplay/rally/tools/devTools.lua
for i, point in ipairs(points) do
-- dump(point.pos)
table.insert(self.pacenotesTools.drivelinePoints, vec3(point.pos))
@/lua/common/jsonPrettyEncoderCustom.lua
local json = require('jsonPrettyEncoderCustom').encode(exampleTable, nil, nil, tblWeights, foldingCallback)
dump(json)
@/lua/vehicle/controller/inputOutputDemo.lua
local data = udpSocket:receive()
dump(data)
--do something with the data
@/lua/vehicle/controller/drivingDynamics/sensors/vehicleData.lua
--print(configFilePath)
--dump(configContent)
if configContent.vehicleData then
@/lua/vehicle/controller/gauges/analogOdometer.lua
local configData = jbeamData.configuration or {}
--dump(configData)
for k, v in pairs(jbeamData) do
end
--dump(configData)
@/lua/ge/extensions/gameplay/drag/debug.lua
if im.Button("Lanedata: " .. key) then
dump(laneData.transform)
end
if im.Button("Dump Vehicle data") then
dump(dragData.racers[selectedVehicle])
end
@/lua/ge/extensions/editor/gen/lib/ai.lua
end)
-- dump(g, '?? for_g:'..N)
for i,c in pairs(ac) do
end
-- dump(ac, '?? step:'..N)
N = N+1
end
-- dump(g, '?? for_G:')
-- lo('<< go:'..N..':'..(dl/L)..':'..cL..'/'..L..':'..(cL/L))
local cac = step(ac, k, s)
-- U.dump(cac, '?? cac:'..k)
-- U.dump(ac, '?? ac:')
-- U.dump(cac, '?? cac:'..k)
-- U.dump(ac, '?? ac:')
-- ac[k] = v + rat/2
-- lo('?? g_7:'..N..':'..g[7]..':'..ac[7])
-- dump(g, '?? for_g:'..N)
for i,c in pairs(ac) do
end
-- dump(ac, '?? step:'..N)
cL = loss(ac)
end
-- dump(g, '?? for_G:')
-- lo('<< go:'..N..' dL:'..(dl/L)..' cL:'..cL..'/'..L..':'..(cL/L))
ac = ac or {a.x, a.y, a.z, b.x, b.y, b.z}
-- dump(ac, '?? AC0:')
-- local ac = {1,2,3,4,5,6}
-- dump(ac, '<< line.ac:'..tostring(L2)..'/'..tostring(L1)..':'..(L2/L1))
@/lua/ge/extensions/ui/liveryEditor/layerAction.lua
local performReproject = function(layer)
dump("PERFORM REPROJECT", layer)
local lastIndex = uiLayers.getChildrenCount()
@/lua/vehicle/controller/drivingDynamics/actuators/activeDiffBias.lua
end
--dump(M.wheelSides)
@/lua/ge/extensions/core/commandhandler.lua
--log('E', 'scheme', ' === === === === === === === === ===')
--dump(args)
@/lua/ge/extensions/editor/trafficManager.lua
if not shipping_build and im.Button("Dump Data (Debug)") then
dump(session)
end
@/lua/ge/extensions/editor/crawlEditor.lua
if FS:fileExists(newFilePath) then
dump('[CRAWL_EDITOR] Cannot rename: target file already exists: ' .. newFilePath)
return false
if not success then
dump('[CRAWL_EDITOR] Failed to rename file from ' .. oldFilePath .. ' to ' .. newFilePath)
return false
dump('[CRAWL_EDITOR] Successfully renamed ' .. objectType .. ' from ' .. oldFilePath .. ' to ' .. newFilePath)
return true
dump(string.format('[CRAWL_EDITOR] Found files - Trails: %d, Paths: %d, Boundaries: %d, Starting Positions: %d',
#trailFiles, #pathFiles, #boundaryFiles, #startingPositionFiles))
dump(string.format('[CRAWL_EDITOR] Loaded %d trails, %d mission trails, %d paths, %d mission paths, %d boundaries, %d mission boundaries, %d starting positions', #allTrails, #missionTrails, #allPaths, #missionPaths, #allBoundaries, #missionBoundaries, #allStartingPositions))
end
if success then
dump('[CRAWL_EDITOR] Trail moved to mission: ' .. (selectedTrail._fileName or 'unnamed'))
else
else
dump('[CRAWL_EDITOR] Failed to move trail to mission')
end
if success then
dump('[CRAWL_EDITOR] Trail moved to level: ' .. (selectedTrail._fileName or 'unnamed'))
else
else
dump('[CRAWL_EDITOR] Failed to move trail to level')
end
selectedTrail._dirty = false
dump('[CRAWL_EDITOR] Marked trail ' .. selectedTrailIndex .. ' (' .. (selectedTrail._fileName or 'unnamed') .. ') as clean after save')
end
selectedPath._dirty = false
dump('[CRAWL_EDITOR] Marked path ' .. selectedPathIndex .. ' (' .. (selectedPath._fileName or 'unnamed') .. ') as clean after save')
end
selectedBoundary._dirty = false
dump('[CRAWL_EDITOR] Marked boundary ' .. selectedBoundaryIndex .. ' (' .. (selectedBoundary._fileName or 'unnamed') .. ') as clean after save')
end
selectedStartingPosition._dirty = false
dump('[CRAWL_EDITOR] Marked starting position ' .. selectedStartingPositionIndex .. ' (' .. (selectedStartingPosition._fileName or 'unnamed') .. ') as clean after save')
end
FS:removeFile(selectedTrail._filePath)
dump('[CRAWL_EDITOR] Deleted trail file: ' .. selectedTrail._filePath)
end
local function testLogging()
dump('[CRAWL_EDITOR] Test logging function called successfully!')
dump('[CRAWL_EDITOR] Current time: ' .. os.date())
dump('[CRAWL_EDITOR] Test logging function called successfully!')
dump('[CRAWL_EDITOR] Current time: ' .. os.date())
return true
@/lua/vehicle/extensions/dynoClient.lua
}
--dump(data)
sendData(textureName, 'client_data', data, dynoObjectID)
@/lua/ge/extensions/ui/vehicleSelector/general.lua
print("callback")
dump(a) dump(b) dump(c) dump(d)
guihooks.trigger("ChangeState", "menu.freeroamselector")
print("callback")
dump(a) dump(b) dump(c) dump(d)
guihooks.trigger("ChangeState", "menu.freeroamselector")
print("callback")
dump(a) dump(b) dump(c) dump(d)
guihooks.trigger("ChangeState", "menu.freeroamselector")
print("callback")
dump(a) dump(b) dump(c) dump(d)
guihooks.trigger("ChangeState", "menu.freeroamselector")
@/lua/ge/extensions/flowgraph/nodes/mission/selectHeistMissionSpots.lua
local vPos = vec3(self.pinIn.position.value)
dump((self.start.pos - vPos):length())
if (self.start.pos - vPos):length() > 400 then
self.indexStart = self.indexStart + 1
dump("skipping start...")
self.start = self.spots.byName[self.startLoc[self.indexStart]]
self.indexStart = self.indexStart + 1
dump("skipping hiest...")
self.hiest = self.spots.byName[self.hiestLoc[self.indexStart]]
self.indexStart = self.indexStart + 1
dump("skipping escape...")
self.escape = self.spots.byName[self.names[self.indexStart]]
@/lua/ge/extensions/editor/assetBrowser.lua
if not data then return end
dump(data)
dump(#data)
dump(data)
dump(#data)
--[[
@/lua/ge/extensions/editor/missionEditor.lua
local missionType = mission.missionType
dump(string.format("%s - %s", mission.careerSetup.skill, mission.id))
if mission.careerSetup.showInCareer and validSkills[mission.careerSetup.skill] then
if mission.careerSetup.showInCareer and validSkills[mission.careerSetup.skill] then
dump(string.format("%s - %s", mission.name, mission.id))
mission.startTrigger = {}
for x in header:gmatch("([^',']+)") do table.insert(keys, x) end
dump(keys)
local row = f:read()
for x in row:gmatch("([^,]+)") do
dump(x)
--print(idx, x)
end
dump("Words: " .. wordCount)
writeFile("translationText.json",table.concat( translationStrings, ",\n")..",\n")
@/lua/vehicle/extensions/tech/CANBus/RacingDisplay.lua
--dumpz(wheels.wheels[0], 1)
--dump(electrics.values.turboBoost)
end
@/lua/ge/extensions/flowgraph/nodes/ui/startScreen.lua
function C:closeDialogue()
-- dump("closing dialogue!")
--core_gamestate.setGameState('freeroam', 'freeroam', 'freeroam')
self.open = true
-- dump("opening dialogue!")
@/lua/ge/extensions/util/testExtensionProxies.lua
--print(' == testInstances ==')
--dump(testInstances)
@/lua/ge/extensions/util/trackBuilder/basicCenters.lua
--dump(minWidth .. " " ..shape.LUTMin .. " - " .. shape.LUTMax .. " " .. maxWidth)
@/lua/ge/extensions/campaign/rewards.lua
--dump(reward)
return reward
@/lua/ge/extensions/flowgraph/nodes/util/customLua.lua
data.pos = nil
dump(data)
customNodes[self.name] = data
@/gameplay/missionTypes/generatedTimeTrial/constructor.lua
if #self.missionTypeData.prefabs <= 1 and #self.missionTypeData.forwardPrefabs <= 1 and #self.missionTypeData.reversePrefabs <= 1 then
dump(string.format("OK! %s has: %d %d %d prefab counts", self.id, #self.missionTypeData.prefabs, #self.missionTypeData.forwardPrefabs, #self.missionTypeData.reversePrefabs))
else
else
dump(string.format("%s has: %d %d %d prefab counts", self.id, #self.missionTypeData.prefabs, #self.missionTypeData.forwardPrefabs, #self.missionTypeData.reversePrefabs))
end
@/lua/ge/extensions/flowgraph/nodes/ui/updatedUI/endScreenTimeSlip.lua
local slipData = gameplay_drag_general.createTimeslipData()
--dump(dragData)
if not slipData then
@/lua/ge/extensions/flowgraph/nodes/events/customizedTriggerBox.lua
else
--dump("Checking: " .. dumps(cPos))
--dump("Against: " ..dumps(self.trigger.pos) .. " X: " .. dumps(self.trigger.x) .. " Y: " .. dumps(self.trigger.y) .. " Z:".. dumps(self.trigger.z))
--dump("Checking: " .. dumps(cPos))
--dump("Against: " ..dumps(self.trigger.pos) .. " X: " .. dumps(self.trigger.x) .. " Y: " .. dumps(self.trigger.y) .. " Z:".. dumps(self.trigger.z))
--dump("Result is: " .. (containsEllipsoid_Point(self.trigger.pos, self.trigger.x, self.trigger.y, self.trigger.z, cPos) and "True" or "False"))
--dump("Against: " ..dumps(self.trigger.pos) .. " X: " .. dumps(self.trigger.x) .. " Y: " .. dumps(self.trigger.y) .. " Z:".. dumps(self.trigger.z))
--dump("Result is: " .. (containsEllipsoid_Point(self.trigger.pos, self.trigger.x, self.trigger.y, self.trigger.z, cPos) and "True" or "False"))
inside = inside or containsEllipsoid_Point(self.trigger.pos, self.trigger.x, self.trigger.y, self.trigger.z, pos)
@/lua/vehicle/extensions/tech/CANBus/ProjectBavariaController.lua
--dump({x1, y1})
--dumpByte(band(x1Quadrant, 0xF0))
@/lua/vehicle/extensions/tech/platooning.lua
for i = 1, #A do
dump(A[i])
end
@/lua/vehicle/powertrain/combustionEngineThermals.lua
end
--dump(tmpExhaustEndNodes)
--dump(nodes.exhaustEnds)
M.exhaustEndNodes = nodes.exhaustEnds
--dump(exhaustTrees)
--print(afterFire.exhaustMaxLevel)
end
--dump(tmpExhaustNodes)
--dump(nodes.exhaustEnds)
--dump(tmpExhaustEndNodes)
M.exhaustEndNodes = nodes.exhaustEnds
@/lua/ge/extensions/core/cameraModes/unicycle.lua
if newGround.z < oldGround.z then
--dump("ground known, falling towards it")
newGround.z = max(oldGround.z + gravity*dt, newGround.z)
else
--dump("ground known, immediately climbing it")
newCamPos = newGround + vec3(0,0,getHumanHeight(crouching))
if prevCamPos then
--dump("ground unknown, reverting")
--newCamPos = prevCamPos
else
--dump("ground unknown, falling into the abyss?")
newCamPos = camPos + vec3(0,0, gravity*dt)
--local rotVec = vec3(math.deg(rotEuler.x), 180+math.deg(rotEuler.y), math.deg(rotEuler.z))
--dump(string.format("%5.3f, %5.3f, %5.3f", rotVec.x, rotVec.y, rotVec.z))
return rotVec
@/lua/ge/extensions/gameplay/discover.lua
-- use this to get the position, rotation and partConfig of all vehicles
for id in activeVehiclesIterator() do local veh = scenetree.findObjectById(id) print(veh) dump({veh:getPosition(), quatFromDir(veh:getDirectionVector(), veh:getDirectionVectorUp()), veh.jbeam, veh.partConfig}) end
]]
@/lua/ge/extensions/editor/flowgraph/properties.lua
if editEnded[0] then
--dump({cdata[path].clr[0],cdata[path].clr[1],cdata[path].clr[2],cdata[path].clr[3], cdata[path].other[1][0]})
saveCallback(savePath, {
@/lua/ge/extensions/core/modmanager.lua
--log('D', 'updateZIPEntry', "new zip:")
--dump(d)
end
--dump(mods)
stateChanged()
-- local deleteFileList = FS:findFiles( folderPath, "*", -1, true, true )
--dump(deleteFileList)
-- for i = #deleteFileList, 1, -1 do
if data then
dump(data)
end
Engine.Platform.taskbarSetProgressState(2)
--dump(files)
local extractionRes = true
--local files = zip:getFileList()
--dump(files)
safeDeleteFolder(mods[modname].unpackedPath)
@/lua/ge/extensions/flowgraph/nodes/vehicle/randomConfigProvider.lua
end
--dump(self.options)
end
self.pinOut.name.value = cnf.name
--dump(opt.colors)
if opt.paints and #opt.paints > 0 then
@/lua/ge/extensions/ui/liveryEditor/controls.lua
M.useMouseProjection = function()
dump("useMouseProjection")
-- local isUseMousePos = api.isUseMousePos()
M.useCursorProjection = function()
dump("useCursorProjection")
-- local isUseMousePos = api.isUseMousePos()
M.useActionMap = function(actionMapKey)
-- dump("useActionMap", actionMapKey)
disableAllActionMaps()
if actionMap then
-- dump("useActionMap", actionMap)
pushActionMap(actionMap)
-- api.setDecalColor(Point4F(1, 1, 1, 1))
-- dump("toggleUseMousePos", api.settingsFlags.UseMousePos)
-- dump("settings", api.isUseMousePos())
-- dump("toggleUseMousePos", api.settingsFlags.UseMousePos)
-- dump("settings", api.isUseMousePos())
-- end
M.liveryEditor_OnUseMousePosChanged = function(value)
dump("liveryEditor_OnUseMousePosChanged", value)
if value then
@/lua/ge/extensions/flowgraph/nodes/ui/customUiLayout.lua
self.storedLayout = data.apps
--dump(data)
end
@/gameplay/missionTypes/scatterPickup/customNodes/scatterPrefabSetupNode.lua
list = arrayShuffle(list)
--dump(list)
return list
@/lua/ge/extensions/scenario/quickRaceLoader.lua
local trackBuilderTracks = M.getTrackEditorTracks()
--dump(files)
for _, levelName in ipairs(files) do
end
--dump(scenarioFile.lapConfig)
-- dump("End = " .. trackFile.startLineCheckpoint)
local disableToD = false
if scenarioFile.levelInfo.disableQuickraceTimeOfDay then disableToD = true end
--dump(scenarioFile.levelInfo)
if not disableToD then
}
--dump(trackFile.tod)
else
local quickraceScenario = loadQuickrace(nil, scenarioFile, trackFile, vehicleFile, raceType)
-- dump(quickraceScenario)
scenario_scenarios.executeScenario(quickraceScenario)
@/lua/ge/extensions/career/modules/linearTutorial.lua
-- dump(career_modules_linearTutorial.getTutorialData())
M.getTutorialData = function() return saveData end
@/lua/ge/extensions/editor/gen/test.lua
-- local alod = M.daeFrom('/art/shapes/common/building_architect_modules/roof_border/SH_F_Rco_01_100x100_test.dae')
-- U.dump(alod[1], '?? LOD:',nil,2)
-- local alod = M.daeFrom('/art/shapes/common/building_architect_modules/roof_border/SH_F_RC_01_100x50_test.dae')
-- local alod = M.daeFrom('/art/shapes/common/building_architect_modules/roof_border/SH_F_RC_01_100x50_test.dae')
-- U.dump(alod[1].list[1].m.verts, '?? for_DAE:', nil, 2)
if true then return end
-- U.dump(desc.afloor[cij[1]].awall[cij[2]].plinth,'?? for_PLINTH:')
local plinth = desc.afloor[cij[1]].awall[cij[2]].plinth
local am = {alod[1].list[1].m}
U.dump(alod[1].list[1].m, '?? for_ALOD:'..#alod..':'..#alod[1].list..':'..#am[1].verts,nil,2)
-- M.flipSide(am[1].faces, am[1].normals)
end
U.dump(cij, '?? for_:',nil,2)
return
local obj = U.fromJSON(U.fromFile('/tmp/fpave2.json'))
U.dump(obj, '?? for_O:')
local aloop = {obj.aloop[1],obj.aloop[2],obj.aloop[3],obj.aloop[4],obj.aloop[5],obj.aloop[6]}
local obj = U.fromJSON(U.fromFile('/tmp/fpave3.json'))
-- U.dump(obj, '?? for_O:')
local aloop = obj.aloop -- {obj.aloop[1],obj.aloop[2],obj.aloop[3],obj.aloop[4],obj.aloop[5],obj.aloop[6]}
local obj = U.fromJSON(U.fromFile('/tmp/fspline1.json'))
-- U.dump(obj, '?? for_O:')
local aloop = obj.aloop -- {obj.aloop[1],obj.aloop[2],obj.aloop[3],obj.aloop[4],obj.aloop[5],obj.aloop[6]}
end
U.dump(aseq, '?? if_OK:'..tostring(mbody)..':'..tostring(pmi)) --..':'..#aloop)
return
local astep = obj.astep
U.dump(astep, '?? for_AS:')
end
U.dump(desc.aspline, '?? d_ASPLINE:'..tostring(desc.id))
-- start edit
d.selection[1] = {1,3,2}
-- U.dump(d.afloor[1].awall[1], '?? floor:')
if #d.selection == 1 then
table.sort(aw)
U.dump(aw, '?? w_SEL:')
h = d.afloor[j].h
base[#base+1] = wall.pos
-- U.dump(wall, '?? for_WALL:'..iw)
if not win then
if not win then
-- U.dump(ddae[wall.win], '?? for_WDAE:'..wall.win)
win = ddae[wall.win]
end
U.dump(base,'?? base:')
-- U.dump(astep, '?? ASTEP:'..L)
-- U.dump(adist, '?? ADIST:'..L)
-- U.dump(astep, '?? ASTEP:'..L)
-- U.dump(adist, '?? ADIST:'..L)
-- doorind = 0
end
-- U.dump(ahole, '?? aHOLE:'..doorind..' nW:'..nwin..' wL:'..winleft)
-- local p1,p2 = ap[1],ap[2]
-- local lst = U.circ2seg(c,r,p1,p2,U.small_val)
-- U.dump(lst, '??*********** if_HIT:'..#lst..':'..tostring(c)..' r:'..r..'/'..c:distance(p1)..':'..c:distance(p2)..':'..tostring(p1)..':'..tostring(p2))
meshUp({mbody}, 'tst', groupEdit)
-- U.dump(mbody, '?? mbody:')
end
-- lo('?? MI:'..tostring(m.obj:getPosition()))
-- U.dump(m, '?? for_OBJ:')
-- for k,v in pairs(m.obj) do
local ascan = W.buildingScan(desc, function(ascan)
-- U.dump(ascan, '?? for_SCAN:')
local auv = tex2uv(ascan)
local auv = tex2uv(ascan)
-- U.dump(auv, '?? for_SCAN:')
local arc = {}
end)
U.dump(arc, '?? for_SCAN:')
--TODO: automate texture merging
lo('??^^^^^^^^^^ if_KIDS:'..tableSize(nodevs.kids)..':'..tostring(nd_maingeo.attr['id'])) --..tostring(nd_maingeo.kids[2].name)) --..tostring(tableSize(nd_maingeo.kids[2])))
-- U.dump(nd_maingeo)
-- for _,k in pairs(nodevs.kids) do
end
-- U.dump(pos, '?? for_data:'..tostring(base[2]))
--[[
meshUp({mbody}, 'tst', groupEdit)
-- U.dump(mbody, '?? mbody:')
end
}, 5, true)
U.dump(mbody)
-- lo('?? if_TUBE:'..tostring(af))
if M.valid({mbody}) then
-- U.dump(mbody, '?? test_mdata:'..tostring(aedge))
meshUp({mbody}, 'tst', groupEdit)
local b1, b2 = polySplit(base, true)
U.dump(b1, '?? split1:')
U.dump(b2, '?? split2:')
U.dump(b1, '?? split1:')
U.dump(b2, '?? split2:')
-- local arc = coverUp(base,true)
-- local arc = coverUp(base,true)
-- U.dump(arc, '?? test_arc:')
end
if M.valid({mbody}) then
-- U.dump(mbody, '?? test_mdata:'..tostring(aedge))
meshUp({mbody}, 'tst', groupEdit)
local mbody,mhole,ae,apath,albl = M.rcPave(base, aloop)
-- U.dump(mbody, '?? mbody:')
-- U.dump(apath, '?? mhole:')
-- U.dump(mbody, '?? mbody:')
-- U.dump(apath, '?? mhole:')
for i=1,#mbody.faces,3 do
local arc = coverUp(base)
U.dump(arc, '?? test_ARC:')
out.apath = arc
lo('?? GABLED:'..tostring(adata and #adata or nil))
-- U.dump(adata, '?? GABLED:')
end
local arc = coverUp(base)
U.dump(arc, '?? test_CU_arc:')
end
end
-- U.dump(av, '?? base2:'..math.random(0.5))
local base = {
-- local apair,amult = T.pairsUp(av)
-- U.dump(apair, '?? pairs:')
-- U.dump(amult, '?? mults:')
-- U.dump(apair, '?? pairs:')
-- U.dump(amult, '?? mults:')
local adata = T.forGable(av,nil,true) --, apair, W)
jsonWriteFile(pth..'/top.materials.json', dmat)
U.dump(amat,'?? json_DONE:'..tableSize(dmat))
local an,auv,af = M.zip2(base, {1,2,3,4}) --, {2,3,4,5,6,7})
-- U.dump(af, '?? test_AF:')
-- U.dump(auv, '?? test_AUV:')
-- U.dump(af, '?? test_AF:')
-- U.dump(auv, '?? test_AUV:')
local mdata = {
local an,auv,af = M.zip2(base, {2,3,4,5,6,7})
-- U.dump(an, '?? for_AN:')
-- U.dump(af, '?? for_AF:')
-- U.dump(an, '?? for_AN:')
-- U.dump(af, '?? for_AF:')
local mdata = {
local av,auv,af = T.pave(base)
U.dump(av, '?? test_AV:')
U.dump(af, '?? test_AF:')
U.dump(av, '?? test_AV:')
U.dump(af, '?? test_AF:')
if true then return end
base = U.polyMargin(base, 0.4)
U.dump(base, '?? BASE:')
-- T.pave(base)
base = U.polyMargin(base, 0.4)
U.dump(base, '?? BASE:')
-- T.forRidge(nil, base)
-- lo('?? for_ridge:'..#av..':'..#auv..':'..#af)
U.dump(av, '?? AV:')
U.dump(af, '?? AF:')
U.dump(av, '?? AV:')
U.dump(af, '?? AF:')
base = sbase
end
-- U.dump(af, '?? AF:'..#af)
if true then return end
if false then
U.dump(out.fwhite, '?? fwhite:')
U.dump(out.fyell, '?? fyell:')
U.dump(out.fwhite, '?? fwhite:')
U.dump(out.fyell, '?? fyell:')
U.dump(out.flbl, '?? flbl:')
U.dump(out.fyell, '?? fyell:')
U.dump(out.flbl, '?? flbl:')
end
end
-- U.dump(out.fyell, '?? fyell2:')
-- U.dump(out.fwhite[1], '?? fwhite:'..#out.fwhite)
-- out.avedit = {vec3(-265,1148,1)}
@/lua/ge/extensions/util/wsTest.lua
if evt.type == 'D' and evt.msg ~= '' then
--dump({"event: ", evt})
if evt.msg == 'ping' then
@/lua/common/jbeam/loader.lua
end
--dump({'chosenPartsTree = ', chosenPartsTree})
@/lua/ge/extensions/editor/dynamicDecals/inspector.lua
local function inspectLayerGui(layer, guiId)
if im.Button(string.format("Dump##%s_%s", layer.uid, guiId)) then dump(layer) end
if editor.getPreference("dynamicDecalsTool.general.debug") then
@/lua/ge/extensions/editor/rallyEditor/pacenotes/customForm.lua
-- local dir = path.dirname(fname)
-- dump(dir)
local dir = pacenote:customAudioFileDir()
@/flowgraphEditor/Tower/customNodes/towerNode.lua
list = arrayShuffle(list)
--dump(list)
return list
dump(list)
@/lua/common/utils/httpJsonServer.lua
--print("got request:")
--dump(request)
if not request.uri then return end -- returns 500
local data = prepareEditorData()
--dump(data)
return data
@/lua/ge/extensions/ui/liveryEditor/tools.lua
M.doOperation = function(funcOperation, ...)
dump("doOperation editModeState", M.editModeState)
if M.editModeState.active then
M.liveryEditor_editMode_onStateChanged = function(data)
dump("liveryEditor_editMode_onStateChanged", data)
for k, v in pairs(data) do
@/lua/ge/ge_utils.lua
--log('E', logTag,'scenetree.__index('..tostring(class_table) .. ', ' .. tostring(memberName)..')')
--dump(class_table)
-- 1. deal with methods on the actual lua object: like get/set below
local obj = scenetree.findObject('sunsky')
--dump(obj)
local obj = SimFieldTestObject("TestObj")
--dump(obj)
local files = zip:getFileList()
dump(files)
for i,v in ipairs(files) do
end
--dump(inp)
tod.time = (((inp.hours * 3600 + inp.mins * 60 + inp.secs) / 86400) + 0.5) % 1
}
dump(obj2.internalName)
@/lua/ge/extensions/core/gamestate.lua
if tagName == nil then return end
--dump(loadingScreenRequests)
--print(debug.tracesimple())
@/lua/ge/extensions/editor/rallyEditor/pacenotes/pacenoteForm.lua
}
-- dump(dumpData)
end
@/lua/vehicle/controller/shiftLights.lua
--dump(lightSteps)
end
@/lua/ge/extensions/statistics/statistics.lua
log('D', logTag, 'getVehicleStat called...')
--dump(vehicleTable)
local entry = {}
-- dump(data)
entry.label = data.label
for i,entry in ipairs(altitudeProperties) do
-- dump(entry)
if entry.target == vehicleName then
-- log('D',logTag, 'damage count: ' .. i)
-- dump(entry)
if entry.target == vehicleName then
for i,entry in ipairs(distanceProperties) do
-- dump(entry)
if entry.target == vehicleName then
end
-- dump(statsTable[vehicleID] )
end
for i,entry in ipairs(speedProperties) do
-- dump(entry)
if entry.target == vehicleName then
-- dump(statsTable[vehicle:getID()])
end
log('D', logTag, 'onDeserialized called...')
-- dump(data)
statsTable = convertVehicleNameKeysToVehicleIdKeys(data.statsTable)
scenarioStats = data.scenarioStats
-- dump(scenarioStats)
-- dump(statsTable)
-- dump(scenarioStats)
-- dump(statsTable)
end
@/lua/ge/extensions/editor/trafficSignalsEditor.lua
for _, s in ipairs(simLogs) do
dump(s)
end
@/lua/ge/extensions/ui/apps.lua
end
--dump(appData)
else
if not data['filename'] then
dump({'invalid layout save data. Filename missing: ', data})
return
jsonWriteFile(filename, data, true)
--dump({'saved layout: ' .. tostring(filename), data})
requestUIAppsData()
local function deleteLayout(filenameToDelete)
--dump({'deleteLayout', filenameToDelete})
local layouts = getAvailableLayouts()
for _, layout in ipairs(layouts) do
--dump({'delete?', layout.filename, filenameToDelete})
if layout.filename == filenameToDelete then
@/lua/ge/extensions/flowgraph/nodes/environment/planet.lua
--dumpz(cubeGrid,2)
--dump(cubeGrid)
local rots = {
local startPos = centerCoordinates[identifier]
--dump(startPos)
for y = 1, size+2 do
end
--dump(heightmap)
end
--dump(heightmap)
return heightmap
@/lua/ge/extensions/ui/liveryEditor/editMode.lua
-- M.liveryEditor_OnLayerAdded = function(layer)
-- dump("liveryEditor_OnLayerAdded > editMode.active", M.active)
-- if not M.active or layer.type == api.layerTypes.linkedSet then
-- M.onUpdate = function(dtReal, dtSim)
-- -- dump("update", {dtReal, dtSim})
-- -- if M.highlightTimer then
-- -- if M.highlightTimer and M.highlightTimer >= 5 then
-- -- dump("HEEEEERREEEEE")
-- -- if api.getHighlightedLayer() then
@/lua/ge/extensions/career/modules/tether.lua
log("I","","Broke tether!")
dump(t)
end
@/lua/ge/extensions/gameplay/missions/progress.lua
local defaults, bonus = {}, {}
--dump(sortedKeys)
for i = 1, #sortedKeys do
dumpz(mission, 2)
dump("no attempt generator?")
return
end
dump(attempt)
local totalChange = M.aggregateAttempt(id, attempt, mission.defaultProgressKey)
if dumpChange then
dump(totalChange)
end
@/gameplay/missionTypes/timeTrial/constructor.lua
--if self.id == "west_coast_usa/timeTrial/024-Spearloop" then
--dump(self.missionTypeData)
--end
@/lua/ge/extensions/scenario/waypoints.lua
end
--dump(from)
end
data.currentBranch = M.state.currentBranch
-- dump(data)
return data
@/lua/ge/extensions/util/trackBuilder/markers.lua
if doChange then
--dump("Found Values for " .. nameOfField .. ": " .. startValue .. " to " .. endValue .. " ("..startIndex .. " - " .. endIndex..")" .. "["..startLength .. " - " .. endLength .."]")
if startIndex == 1 then startIndex = 0 end
if not changed[i] and track[i].fresh and startValue then
--dump("track " .. i .. " is fresh..." .. nameOfField .. " / " .. " / " .. startLength)
--dump(startValue)
--dump("track " .. i .. " is fresh..." .. nameOfField .. " / " .. " / " .. startLength)
--dump(startValue)
M.interpolatePointsOfSegment(track[i],startValue,nil,startLength,nil, nameOfField)
if closed then
--dump("closed")
compareSimpleCaps(segments[#segments],segments[2],nameOfField)
if closed then
-- dump("Closed wall")
-- dump(segments[#segments].meshInfo)
-- dump("Closed wall")
-- dump(segments[#segments].meshInfo)
-- dump(segments[2].meshInfo)
-- dump(segments[#segments].meshInfo)
-- dump(segments[2].meshInfo)
compareWallCeilingCaps(segments[#segments],segments[2],nameOfField)
markerChanges[name][#markerChanges[name]+1] = index
--dump('added makrer change for ' .. name .. ' on ' .. index)
end
@/lua/ge/extensions/flowgraph/nodes/ui/missionPopup.lua
self.open = true
-- dump("opening dialogue!")
local data = {}
@/lua/ge/extensions/gameplay/util/damageAssessment.lua
-- dump(textualDamageLocations.mostDamagedLocation)
-- if location.name == "Front Center" or location.name == "Front Left" or location.name == "Front Right" or location.name == "Front"then
-- dump(textualDamageLocations.damagedLocations[location.name])
-- end
@/lua/ge/extensions/ui/liveryEditor/tools/material.lua
M.setColor = function(rgbaArray)
dump("setColor", rgbaArray)
uiTools.doOperation(function(layer, color)
M.setMetallicIntensity = function(metallicIntensity)
dump("setMetallicIntensity", metallicIntensity)
uiTools.doOperation(function(layer, metallicIntensity)
M.setRoughnessIntensity = function(roughnessIntensity)
dump("seRoughnessIntensity", roughnessIntensity)
uiTools.doOperation(function(layer, metallicIntensity)
M.setNormalIntensity = function(normalIntensity)
dump("setNormalIntensity", normalIntensity)
uiTools.doOperation(function(layer, normalIntensity)
@/lua/ge/extensions/core/inventory.lua
-- log('I', logTag, 'existItem called ... type(entryTable) = '..type(entryTable) ..' type(valueObj) = '..type(valueObj))
-- dump(entryTable)
-- dump(valueObj)
-- dump(entryTable)
-- dump(valueObj)
local found
-- dump(itemsTable)
end
-- log('I', logTag, 'after removeItem')
-- dump(M.itemsTable)
end
-- log('I', logTag, 'processTable called... operation: '..tostring(operation)..' key: '..key)
-- dump(entry)
local function onDeserialized(data)
-- dump(data)
end
@/lua/ge/extensions/flowgraph/nodes/vehicle/ai/scriptAI/followPath.lua
veh:queueLuaCommand('ai.startFollowing(' .. serialize({path=path}) .. ',nil,'..loopCount..',"'..loopType..'")')
--dump('ai.startFollowing(' .. serialize(self.path) .. ',)')
end
@/gameplay/missionTypes/hypermiling/customNodes/getFuelLevelNode.lua
if not veh then return end
core_vehicleBridge.requestValue(veh, function(res)dump(res) end, 'energyStorage')
core_vehicleBridge.requestValue(veh, function(res)self.pinOut.fuelLevel.value = res.currentEnergy end, 'energyStorage')
@/lua/ge/extensions/util/compileMeshes.lua
--dump(compiledFiles)
@/lua/ge/extensions/editor/dynamicDecals/brushes.lua
if im.Button("dump") then
dump(brush)
end
if im.Button("Dump Brush##BrushContextModal") then
dump(brushesData[brushContextModal_brushId])
im.CloseCurrentPopup()
@/lua/ge/extensions/flowgraph/nodes/scene/particleEmitter.lua
self.object.obj = self:createObject("particles_"..nm)
--dump("Added Object")
scenetree.MissionGroup:addObject(self.object.obj.obj)
@/lua/ge/extensions/flowgraph/nodes/util/ghost.lua
if im.Button("Dump ghost data") then
dump(self.ghostData)
end
@/lua/ge/extensions/tech/sensors.lua
isVehicleFeedingComplete = true
dump('Test complete!')
end
@/lua/ge/extensions/util/groundModelDebug.lua
i = i + 1
-- dump(groundModels[k].data:as_table())
end
end
dump(data)
jsonWriteFile(groundModelPath, data, true)
@/lua/ge/extensions/freeroam/bigMapMarkers.lua
local filteredPois = {}
--dump(settings.validIdsLookup)
--local validCopy = deepcopy(settings.validIdsLookup)
end
--dump(validCopy)
table.sort(filteredPois, idSort)
@/lua/ge/extensions/gameplay/drift/saveLoad.lua
local levelSpotsDir = "/levels/"..level .. "/driftSpots/"
--dump(levelSpotsDir)
for _, file in ipairs(FS:findFiles(levelSpotsDir, "spot.driftSpot.json", -1, false, true)) do
end
--dump(tableKeysSorted(spotsById))
if career_career.isActive() then
@/lua/ge/extensions/flowgraph/nodes/scene/storeStatics.lua
function C:updateStoredObjects(ids)
--dump("Updating")
table.clear(self.storedObjects)
self._objectesExistedBeforeStart = nil
--dump("Clearing.")
--if #self.objects == 0 then return end
function C:spawnObjects(force)
--dump("Spawning")
if not force and #self.objects > 0 then
local ids = {}
--dump("Preparuing to spawn.")
for _, o in ipairs(self.storedObjects) do
end
--dump("Spawn Done.")
--dump(ids)
--dump("Spawn Done.")
--dump(ids)
function C:destroy()
--dump("Destroy")
--dump(self._objectesExistedBeforeStart)
--dump("Destroy")
--dump(self._objectesExistedBeforeStart)
if not self._objectesExistedBeforeStart then
@/lua/console/bananabench.lua
end
--dump(t)
--local diff = t.res[2].Mbeamspersec / t.res[1].Mbeamspersec
@/lua/ge/main.lua
local filenames = FS:findFiles('/', pattern, -1, true, false)
-- dump(filenames)
for _, fn in pairs(filenames) do
@/lua/ge/extensions/flowgraph/nodes/vehicle/getElectricsValue.lua
function C:clearNotification()
--dump(self._setupData)
if self._setupData then
@/lua/ge/extensions/flowgraph/nodes/logic/booleanExpression.lua
function C:onUnlink(link)
--dump(link.targetPin.name)
end
@/lua/ge/extensions/freeroam/dragRace.lua
--opponentVehicle:setField('name', '', opponentVehicleName)
--dump(opponentVehicle.name)
opponentVehicle:queueLuaCommand('controller.setFreeze(0)')
@/lua/ge/extensions/editor/gen/mesh.lua
if not space then space = 0 end
U.dump(m, '?? align:'..tostring(pfr)..':'..tostring(pto))
-- to()
local vscale = vec3(1,1,1) + dir*sc
-- U.dump(daedesc, '?? fillSegment:'..l..':'..tostring(b-a)..':'..daedesc.len..':'..n..' scale:'..scale) --..tostring(M.fdata))
local ang = U.vang(U.vturn(b-a, math.pi/2), daedesc.front, true)
-- scale = 0.5
-- U.dump(daedesc,'?? for_N:'..n..':'..step..'/'..(b-a):length()..':'..tostring(vscale)..' l:'..l)
for i = 1,n do
if dbg then
U.dump(base, '?? uv4poly:'..tostring(u)..':'..tostring(v)..':'..tostring(w)..' ref:'..tostring(ref), true)
end
if not scale then scale = {1,1} end
-- U.dump(uvini, '>> forUV:')
-- if not auv then auv = {} end
end
-- U.dump(uvini, '?? ref:'..tostring(ref)..':'..tostring(refuv)..':'..tostring(sideuv))
local u = side:normalized()
end
-- U.dump(base,'>> forBeam:'..tostring(L)..':'..tostring(w))
if not w then return end
-- table.insert(poly,1,base[1] + w*L)
-- U.dump(poly, '?? poly:')
local an,auv,af = M.zip2(poly,ai,nil,nil,nil,nil,uvflip)
-- U.dump(av, '?? for_AV:')
--[[
lo('!!_______________________________________________________________________________ ERR_tri2mdata:')
U.dump(av, '?? AV:')
U.dump(ai)
U.dump(av, '?? AV:')
U.dump(ai)
end
local akey,vn = forNorm(av[ai[1]], av[ai[2]], av[ai[3]])
-- U.dump(akey, '?? tri2madata:')
-- TODO: akey[1] may be NaN
-- if isnan(akey[1])
-- U.dump(akey, '??+++++++++++++++++++++++++ akey:'..tostring(vn)..':'..#an..':'..#av..':'..tostring(ai[1]))
if not dnorm[akey[1]] then dnorm[akey[1]] = {} end
iuvini and {auv[iuvini[1]],auv[iuvini[2]]} or nil, nil, uvscale)
-- U.dump(tuv, '?? for_TUV:'..#auv)
-- local iuvstart =
local akey,vn = forNorm(nil, nil, nil, v)
-- U.dump(akey, '?? zip2_akey:'..tostring(v))
if not isnan(akey[1]) then
-- if isnan(akey[1])
-- U.dump(akey, '??+++++++++++++++++++++++++ akey:'..tostring(vn)..':'..#an..':'..#av..':'..tostring(ai[1]))
if not dnorm[akey[1] ] then dnorm[akey[1] ] = {} end
end
-- U.dump(dnorm, '?? z2_dndnorm:')
-- local auv,an,af,dnorm = {{u=(base[ai[1]]-base[ai[#ai]]):length(),v=0},{u=0,v=0}}
-- U.dump(auv, '?? zip2.auv:')
local N = #ai/2
-- local N = math.floor(L/2)
-- U.dump(aiv, '>> zip:'..#af..' N='..N)
-- local ifr = aiv[1]
end
-- U.dump(af, '?? zip2:'..istart)
-- lo('?? zip:'..N..':'..#aiv..':'..#af)
local N = math.floor(#aiv/2)
-- U.dump(aiv, '>> zip:'..#af..' N='..N)
local istart = N
end
-- U.dump(af, '?? zip2:'..istart)
-- lo('?? zip:'..N..':'..#aiv..':'..#af)
end
-- U.dump(af, '<< zip:')
return af
if not base or #base == 0 then return end
-- U.dump(base, '>> zip:')
av = av ~= nil and av or {}
local function uv4grid(uvx, uvy, ax, ay, X, Y, auv)
-- U.dump(ax, '?? uv4grid_x:')
-- U.dump(ay, '?? uv4grid_y:')
-- U.dump(ax, '?? uv4grid_x:')
-- U.dump(ay, '?? uv4grid_y:')
local u1, u2 = uvx[1], uvx[2]
-- V-F
-- U.dump(vext, '?? grid2mesh_pre:'..#av..':'..#ax..'x'..#ay..':'..u:length())
-- U.dump(ax, '?? grid2mesh_ax:'..#ax)
-- U.dump(vext, '?? grid2mesh_pre:'..#av..':'..#ax..'x'..#ay..':'..u:length())
-- U.dump(ax, '?? grid2mesh_ax:'..#ax)
-- U.dump(ay, '?? grid2mesh_ay:'..#ay)
-- U.dump(ax, '?? grid2mesh_ax:'..#ax)
-- U.dump(ay, '?? grid2mesh_ay:'..#ay)
-- ax = {0,uext[2]/2,uext[2]}
av, af = fromGrid(u, v, ax, ay, skip, av, af, u:length(), v:length(), #auv)
-- U.dump(av, '?? grid2mesh_post:'..#av)
-- U.dump(af, '?? grid2mesh_AF:'..#af)
-- U.dump(av, '?? grid2mesh_post:'..#av)
-- U.dump(af, '?? grid2mesh_AF:'..#af)
-- UV
local function forNode(node, path, lvl, ind, dbg)
-- U.dump(path, '>> forNode:'..tostring(lvl)..':'..tostring(ind))
if not lvl then lvl = 1 end
for _,kid in pairs(node.kids) do
-- U.dump(path, '?? for_PATH:'..lvl)
-- lo('?? forNode:'.._..':'..kid.name..'/'..path[lvl])
-- lo('?? forNode_match:'..nmatch..':'..ind..':'..lvl..':'..kid.name)
if dbg then U.dump(path,'?? match:'..nmatch..'/'..tostring(ind)..':'..tableSize(node.kids)..':'..kid.name) end
if ind == 0 and lvl==#path then
end
-- U.dump({auv[1],auv[2],auv[3],auv[4],auv[5]},'?? PARTS:'..lastMeshInfo.flexmeshesCount)
-- U.out.f = io.open('/tmp/lo1.txt', "w")
-- if i == 0 then
-- U.dump(auvp, '?? auvp:'..i)
-- end
-- lo('?? for_S:'..s)
-- dump(bag, '?? AVP:'..tableSize(bag)..':'..tableSize(avp)..':'..tostring(avp[1]))
-- lo('?? for_AFP:'..#afp..'/'..(endIndex-startIndex+1))
end
-- U.dump(am[1].uvs[1],'<< gpuFrom:'..am[1].name)
lo('<< gpuFrom:'..#am)
-- if stamp == 'rb8r_rb8rr' then
-- U.dump(b,'?? for_STAMP:'..stamp)
-- end
end
-- U.dump(dbeam,'?? m.dbeam:',nil,1)
for part,set in pairs(dbeam) do
-- if #U.index({'rb8r_rb8rr','b3ll_rf1l'},b.stamp) > 0 then
-- U.dump(b, '?? mas:'..b.stamp..':'..tostring(madef)..':'..tostring(maspr)..':'..tostring(mastr))
-- end
end
-- U.dump(abag, '?? aBAG:')
for i,b in pairs(abag) do
end
-- U.dump(po, '?? radiator_PO:')
am[#am+1] = {
-- local ageo = M.forNode(main, {'COLLADA','library_geometries','geometry'},nil,0)
-- U.dump(dmat, '?? DMAT:')
-- if true then return {} end
-- lo('?? to_DGEO:'..k.attr['name'])
-- U.dump(amat[#amat].c, '?? for_C:'..i)
dgeo[k.attr['id']] = {}
amat[#amat+1] = {nm=nm, body=mo, c=c}
-- U.dump(amat[#amat],'?? for_MAT:'..#amat..':'..tostring(mo))
-- lo('?? for_mat:'..tostring(m.material))
local lvs = M.forNode(main, {'COLLADA','library_visual_scenes'})
-- U.dump(dgeo,'??_______________________________ for_LVS:'..tostring(lvs),nil,1)
local out = {}
--[[
U.dump(acell, '??^^^^^^^^^^^^^^^^^ if_MATRIX:'..tostring(mnode)..':'..tostring(mnode.kids[1].value))
local mtx = MatrixF(true)
-- lo('?? for_k_ATTR:'..k.attr['source']..':'..tostring(k.attr.semantic))
-- U.dump(k.attr,'?? for_ATTR:'..tostring(k.attr.semantic))
dsem[k.attr['source']:sub(2)] = k.attr.semantic
end
-- U.dump(dsem, '?? dSEM:')
if dbg then
-- U.dump(auv, '?? for_AV:')
end
-- lo('?? geo_STRIDE:'..stride..':'..ndtri.attr.count)
-- U.dump(dmat, '?? DMAT:')
local mat
if dbg then
U.dump(af, '?? for_AF:')
end
end
U.dump(dmat, '?? geoFrom_mat:'..tostring(t.attr.material))
for k,v in pairs(dmat) do
-- af = fromFA(forNode(ndtri, {'p'}), stride, ndtri.attr.count) --, tricount)
-- U.dump(af,'?? for_DATA:'..#av..':'..#an..':'..#auv..':'..#af)
-- get material
-- lo('?? if_v:'..tostring(v))
-- U.dump(v, '?? if_v:')
-- print(inspect(getmetatable(v)))
for i,m in pairs(am) do
-- U.dump(m, '?? for_m:'..m.material)
if true then
if true then
-- U.dump(m.normals, '?? for_NORM:'..i)
-- end
m.idmat = 'idmat_'..matind
-- U.dump(m, '?? for_m:'..m.idmat)
agid[#agid+1] = 'g_'..i
end
-- U.dump(an, '?? for_AN:')
-- U.dump(av, '?? for_AV:')
-- U.dump(an, '?? for_AN:')
-- U.dump(av, '?? for_AV:')
-- U.dump(m.auv, '?? for_UV:')
-- U.dump(av, '?? for_AV:')
-- U.dump(m.auv, '?? for_UV:')
local sn = U.join(an)
M.toLOD = function(desc, fname, arc, T)
-- U.dump(arc,'?? toLOD:')
local dlod = desc
end
-- U.dump(auv, '?? for_AUV:')
local sn = U.join(an)
local function dae2proc(fname, showlist, step)
U.dump(showlist, '>> dae2proc:'..fname)
-- if showlist == nil then showlist = {} end
-- af[#af + 1] = {v = aint[1][i], n = aint[1][i + 1], u = aint[1][i + 2]}
-- U.dump(af[#af], '?? for_tri:'..i)
end
-- af[#af + 1] = {v = aint[2][i], n = aint[2][i + 1], u = aint[2][i + 2]}
-- U.dump(af[#af], '?? for_tri:'..i)
end
end
-- U.dump(auvi, '?? UV:')
-- U.dump(duvi, '?? UV:')
-- U.dump(auvi, '?? UV:')
-- U.dump(duvi, '?? UV:')
-- lo('?? avi:'..#avi..':'..#verts..':'..#normals..':'..#uvs)
for _,f in pairs(m.faces) do
-- U.dump(f, '?? for_f:'.._..':'..tostring(dvi[f.v])..':'..tostring(dni[f.n])..':'..tostring(duvi[f.u]))
afaces[ord][#afaces[ord]+1] = {v = dvi[f.v]-1, n = dni[f.n]-1, u = duvi[f.u]-1}
end
-- U.dump(amesh, '?? AMESH:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].verts, '?? AMESH1:'..#dmesh[cmesh].sel)
-- U.dump(amesh, '?? AMESH:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].verts, '?? AMESH1:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].normals, '?? AMESH2:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].verts, '?? AMESH1:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].normals, '?? AMESH2:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].uvs, '?? AMESH3:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].normals, '?? AMESH2:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].uvs, '?? AMESH3:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].faces, '?? AMESH4:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].uvs, '?? AMESH3:'..#dmesh[cmesh].sel)
-- U.dump(amesh[1].faces, '?? AMESH4:'..#dmesh[cmesh].sel)
return amesh
end
-- U.dump(list[ord], '?? move:'..ord)
if list == nil then
end
-- U.dump(mdata[1], '>> ifHit:'..#mdata..':'..)
local mi,imi = math.huge,0
local av = m.verts
-- U.dump(m.faces, '?? ifHit:'..#m.verts..':'..#m.faces)
for i = 1,#m.faces,3 do
table.insert(aimi, lastord, {imi})
U.dump(aimi, '?? aimi:')
local path,tri,triord = {},{}
lo('?? pop.to_ref:'..imi)
-- U.dump(m.faces[imi], '?? to>:'..imi)
local ref = to[ord].ref
lo('?? pop.to_ref:'..imi)
-- U.dump(m.faces[imi], '?? to>:'..imi)
tri[#tri + 1] = m.faces[imi+2]
U.dump(m.faces[imi], '?? to>:'..imi)
local istart = #to[ord].faces + 1
end
U.dump(to[ord].ref, '?? REF:')
--[[
to[ord].faces[#to[ord].faces+1] = m.faces[imi]
-- U.dump(m.faces[imi+1], '?? to>:'..imi)
to[ord].faces[#to[ord].faces+1] = m.faces[imi+1]
to[ord].faces[#to[ord].faces+1] = m.faces[imi+1]
-- U.dump(m.faces[imi+2], '?? to>:'..imi)
to[ord].faces[#to[ord].faces+1] = m.faces[imi+2]
-- de['20_15'] = 0
-- U.dump(de, '?? if_DE:'..tostring(de[stamp])..':'..stamp..':'..tostring(onloop))
-- return
lo('?? edgeUp:'..tostring(i)..':'..tostring(j)..':'..tostring(de[stamp])) --..':'..tostring(av[i].star)..':'..tostring(av[j].star))
-- U.dump(av[i].star, '?? STAR_i')
-- U.dump(av[j].star, '?? STAR_j')
-- U.dump(av[i].star, '?? STAR_i')
-- U.dump(av[j].star, '?? STAR_j')
return
if dbg then
U.dump(anew, '?? edgeSplit3:'..tostring(stamp)..':'..tostring(p)..':'..tostring(p:distance(av[seg[1]].pos))..':'..tostring(ifr)..':'..seg[1])
return
-- go over loops
-- U.dump(aloop, '?? fP_ALOOP:')
for i,l in pairs(aloop) do
local nvert = #av
-- U.dump(l,'?? inloop:'..i)
for j,p in pairs(l) do
local ne = tableSize(de)
-- U.dump(av, '?? for_AV:'..ne..':'..#av)
if dbg then U.dump(de, '?? for_DE:'..ne..':'..#av..':'..#aloop) end
-- U.dump(av, '?? for_AV:'..ne..':'..#av)
if dbg then U.dump(de, '?? for_DE:'..ne..':'..#av..':'..#aloop) end
M.out.agraph[1] = {list=apath,c={1,1,1,0.6},w=3}
end
-- U.dump(av, '?? aV_pre:'..#av)
-- if true then return end
-- end
-- U.dump(aline, '?? aLINE:'..#aline)
-- M.out.agraph[2] = {list=aline,c={1,1,0},w=4}
for j=i+1,#aloop do
-- U.dump(aloop[i], '??_____ for_a:'..i)
-- U.dump(aloop[j], '??_____ for_b:'..j)
-- U.dump(aloop[i], '??_____ for_a:'..i)
-- U.dump(aloop[j], '??_____ for_b:'..j)
--[[
-- for b,k in pairs(aloop[j]) do
-- U.dump(l, '?? for_a:'..a)
-- U.dump(k, '?? for_b:'..b)
-- U.dump(l, '?? for_a:'..a)
-- U.dump(k, '?? for_b:'..b)
-- if true then return end
if hit then
-- U.dump(frtoa, '?? frtoA:')
-- U.dump(aloop[i], '?? loopA:'..i)
-- U.dump(frtoa, '?? frtoA:')
-- U.dump(aloop[i], '?? loopA:'..i)
-- U.dump(frtob, '?? frtoB:')
-- U.dump(aloop[i], '?? loopA:'..i)
-- U.dump(frtob, '?? frtoB:')
-- U.dump(aloop[j], '?? loopB:'..j)
-- U.dump(frtob, '?? frtoB:')
-- U.dump(aloop[j], '?? loopB:'..j)
-- merge loops
end
-- U.dump(ifrto, '?? Ifrto:')
-- U.dump(jfrto, '?? Jfrto:')
-- U.dump(ifrto, '?? Ifrto:')
-- U.dump(jfrto, '?? Jfrto:')
if #ifrto == 2 then
end
-- U.dump(loop, '?? loop:')
table.remove(aloop, j)
break
-- U.dump(aloop, '?? aLOOP:')
end
-- U.dump(aloop, '?? aLOOP:'..N)
-- U.dump(av, '?? aV_pre:'..#av)
-- U.dump(aloop, '?? aLOOP:'..N)
-- U.dump(av, '?? aV_pre:'..#av)
-- if true then return end
--[[
U.dump(av, '?? for_AV0:'..tableSize(av)..'/'..#av)
M.out.atext[1] = {list=U.map(av,function(k,v)
end
if dbg then U.dump(av, '?? aV_post_CROSSES:'..#av) end
if dbg then U.dump(de, '?? DE:'..N) end
if dbg then U.dump(av, '?? aV_post_CROSSES:'..#av) end
if dbg then U.dump(de, '?? DE:'..N) end
-- M.out.agraph[#M.out.agraph+1] = {list=apath,c={1,1,0},w=4}
-- M.out.agraph[#M.out.agraph+1] = {list=apath,c={1,1,0},w=4}
-- U.dump(apath, '?? aPATH:'..N)
-- U.dump(aloop, '?? aLOOP:'..N)
-- U.dump(apath, '?? aPATH:'..N)
-- U.dump(aloop, '?? aLOOP:'..N)
-- if true then return end
-- if true then return end
-- U.dump(M.out.atext, '?? for_TT:')
--[[
--[[
U.dump(av, '?? for_AV1:'..tableSize(av)..'/'..#av)
M.out.atext[1] = {list=U.map(av,function(k,v)
end)
-- U.dump(across, '?? for_CROSS:'..i..':'..tableSize(de)..':'..#across)
--- cleanup colinear edges
local adel = {}
-- U.dump(across, '?? PRE_cleaned:'..i)
local ndel = 0
end
-- U.dump(adel, '?? to_DEL:'..#adel)
for j=#adel,1,-1 do
--TODO: for hitting single veertex
-- if dbg then U.dump(across, '?? cleaned:'..i) end
end
-- if true then return end
-- U.dump(across,'?? for_ACROSS:'..#across)
if math.fmod(#across,2) == 0 then
for j=1,#across,2 do
-- U.dump(av,'?? for_AV_pre:'..tableSize(av)..'/'..#av)
-- lo('?? in_cross:'..j..':'..across[j][1]..':'..tostring(l[1]+dir*across[j][2]))
local ind = edgeSplit(across[j][1], l[1]+dir*across[j][2])
-- U.dump(av,'?? for_AV:'..tableSize(av)..'/'..#av)
-- if true then break end
else
U.dump(across, '!!^^^^^^^^^^^^^^^^^^^^^^^ WRONG_CROSS:'..i..':'..tostring(av[29].pos)..':'..tostring(av[30].pos))
--[[
--[[
U.dump(av, '?? for_AV:')
M.out.atext[1] = {list=U.map(av,function(k,v)
--[[
U.dump(across[i+1],'?? for_CR:'..i..':'..j)
if j+1<=#across then
--TODO:
U.dump(across, '!!_________ ODD_CROSS:'..#across)
end
end
-- U.dump(av, '?? for_AV:'..ne..':'..#av)
-- U.dump(de, '?? for_DE_crossed:'..ne..':'..#av)
-- U.dump(av, '?? for_AV:'..ne..':'..#av)
-- U.dump(de, '?? for_DE_crossed:'..ne..':'..#av)
lo('?? DE:'..tableSize(de)..' av:'..#av)
-- U.dump(av, '?? AV:'..tableSize(de))
M.out.aset[3] = {set=U.map(av, 'pos'), c={0.5,0,1}, w=0.005}
-- if true then return end
-- U.dump(set, '?? for_ESET:')
M.out.atext[1] = {list=U.map(av,function(k,v)
--[[
U.dump(av,'?? for_AV:'..#av..':'..N)
M.out.atext[1] = {list=U.map(av,function(k,v)
local a,b = av[e[1]],av[e[2]]
-- U.dump(av[e[2]], '>> next:'..e[1]..'>'..e[2])
local ami,imi = math.huge
done = false
if dbg then U.dump({}, '??++++++ for_edge:'..k) end
local ai = U.split(k,'_')
end
if dbg then U.dump(ai, '??_____________________ AI:'..N..' nloop_macro:'..nloop) end
-- if nloop<3 then
-- if nloop<3 then
-- U.dump(de, '?? DE_2:'..nloop)
-- end
local ang = U.vang(b.pos-a.pos,c.pos-b.pos,true)
-- U.dump(aconc[#aconc], '?? for_ACC0:')
if ang > 0 then
aconc[#aconc+1] = {ai[#ai],ai[1],ai[2]}
-- U.dump(aconc[#aconc], '?? for_ACC:')
-- if #aconc[#aconc] < 3 then
end
if dbg then U.dump(aconc, '??^^^^^^^^^ ACONC:'..N..':'..k..':'..stamp) end
de[k] = 2
-- lo('?? p12:'..tostring(p1)..':'..tostring(p2))
-- U.dump(d, '?? for_SPR1:'..tostring(p1)..':'..tostring(p2))
-- U.dump(ift, '?? for_SPR2:')
-- U.dump(d, '?? for_SPR1:'..tostring(p1)..':'..tostring(p2))
-- U.dump(ift, '?? for_SPR2:')
if p1 then
if p2 then
-- U.dump(ift, '??________ HIT:'..k..':'..tostring(p2)..':'..tostring(av[d[3]].pos)..'>'..tostring(av[d[2]].pos)..':'..tostring(av[ift[1]].pos)..'>'..tostring(av[ift[2]].pos))
local cd = p2:distance(av[d[2]].pos)
if dbg and nloop == 3 then
U.dump(hit1, '??^^^^^ hit1:'..d[2])
U.dump(hit2, '??^^^^^ hit2:'..d[2])
U.dump(hit1, '??^^^^^ hit1:'..d[2])
U.dump(hit2, '??^^^^^ hit2:'..d[2])
end
-- lo('?? d12:'..d1..':'..d2..' fr:'..d[2]..':'..isplit)
-- U.dump(de, '?? DE_PRE:')
-- edgeSplit(U.stamp({ai[isplit],U.mod(isplit+1,ai)},true), d1
if dbg and nloop == 3 then
U.dump(anew, '??***______ post_SPLIT:'..d[2]..':'..ind)
end
-- if d[2] == 15 then
-- U.dump(hit2,'?? pHIT15_:'..d1..':'..d2..':'..tostring(isplit)..':'..tostring(d1
dle[isplit] = nil
-- U.dump(av[#av], '?? post_SPLIT:'..#av)
-- U.dump(de, '?? DE2:')
-- U.dump(av[#av], '?? post_SPLIT:'..#av)
-- U.dump(de, '?? DE2:')
-- if true then break end
N = NMAX
U.dump(hit1, '?? for_DLE1:')
U.dump(hit2, '?? for_DLE2:')
U.dump(hit1, '?? for_DLE1:')
U.dump(hit2, '?? for_DLE2:')
break
--- GET SUBLOOPS
-- U.dump(av[25], '?? v_25:')
local cdone
-- if nloop == 2 then
-- U.dump(ai, '?? pre_CLOOP2:')
-- U.dump(dle, '?? pre_CLOOP2:')
-- U.dump(ai, '?? pre_CLOOP2:')
-- U.dump(dle, '?? pre_CLOOP2:')
-- end
if dbg then
U.dump(dle, '?? pre_CLOOP2:')
end
if dbg and nloop == 3 then
U.dump(aj, '?? small_LOOP:')
end
-- if nloop == 2 then
-- U.dump(acloop, '?? ACLOOP:'..N..':'..nloop)
-- U.dump(dle, '?? DLE:'..N..':'..nloop)
-- U.dump(acloop, '?? ACLOOP:'..N..':'..nloop)
-- U.dump(dle, '?? DLE:'..N..':'..nloop)
-- end
-- lo('?? post_SPROUT:'..#av)
-- U.dump(de, '?? DE_out:'..N..':'..tableSize(de))
-- M.out.aset[3] = {set=U.map(av, 'pos'), c={0.5,0,1}, w=0.01}
end
if dbg then U.dump(acloop, '?? ACLOOP:'..N..':'..nloop) end
-- if true then return end
-- TRIANGULATE
-- U.dump(av, '?? avert:')
local avert = {} --U.map(av, function(k,v)
end
-- U.dump(avert, '?? avert:'..tableSize(avert))
local an,auv,af = {},{},{}
end)
-- U.dump(l, '?? LOOP:'..i)
-- U.dump(map, '?? map:'.._)
-- U.dump(l, '?? LOOP:'..i)
-- U.dump(map, '?? map:'.._)
-- U.dump(pth, '?? pth:'.._)
-- U.dump(map, '?? map:'.._)
-- U.dump(pth, '?? pth:'.._)
-- U.dump(iseq, '?? iseq:')
-- U.dump(pth, '?? pth:'.._)
-- U.dump(iseq, '?? iseq:')
-- an,auv,af = M.zip2(avert, iseq, 0, true, af)
auv = uv4poly(avert, 1)
-- U.dump(avert, '?? AVERT:'..#avert)
-- U.dump(auv, '?? AUV:'..#auv)
-- U.dump(avert, '?? AVERT:'..#avert)
-- U.dump(auv, '?? AUV:'..#auv)
-- U.dump(af, '?? AF:'..#af)
-- U.dump(auv, '?? AUV:'..#auv)
-- U.dump(af, '?? AF:'..#af)
-- U.dump(an, '?? AN:'..#an)
-- U.dump(af, '?? AF:'..#af)
-- U.dump(an, '?? AN:'..#an)
lo('<< framePave:'..N..':'..tostring(u)..':'..w..' invalid:'..tostring(invalid))
local pth,map = U.polyStraighten(pth)
U.dump(map,'?? straihtned:'..#p..'/'..#pth)
local iseq = {}
local pth,map = U.polyStraighten(pth)
-- U.dump(map,'?? straihtned:'..#p..'/'..#pth)
local iseq = {}
end
-- U.dump(iseq, '??++++++ for_loop:'.._)
aloopstamp[#aloopstamp+1] = U.stamp(iseq)
aloopind[#aloopind+1] = p
-- U.dump(p, '?? for_P:'.._)
end
end
-- U.dump(aloopind, '?? loopinds:')
-- U.dump(aestamp, '?? aestamp:')
-- U.dump(aloopind, '?? loopinds:')
-- U.dump(aestamp, '?? aestamp:')
-- U.dump(aloopstamp, '?? stamps:')
-- U.dump(aestamp, '?? aestamp:')
-- U.dump(aloopstamp, '?? stamps:')
-- U.dump(av, '?? av:')
-- U.dump(aloopstamp, '?? stamps:')
-- U.dump(av, '?? av:')
-- U.dump(ae, '?? ae:')
-- U.dump(av, '?? av:')
-- U.dump(ae, '?? ae:')
local p = U.line2seg(U.mod(k,loop), U.mod(k+1,loop),av[ae[ie][1]].p,av[ae[ie][2]].p)
-- U.dump(ae[ie],'?? if_p:'..k..':'..i..':'..tostring(p)..':'..tostring(loop[k])..'>'..tostring(U.mod(k+1,loop))..':'..tostring(av[ae[ie][1]].p)..'>'..tostring(av[ae[ie][2]].p))
if p and U.line2seg(av[ae[ie][1]].p, av[ae[ie][2]].p, U.mod(k,loop), U.mod(k+1,loop)) then
if p and U.line2seg(av[ae[ie][1]].p, av[ae[ie][2]].p, U.mod(k,loop), U.mod(k+1,loop)) then
-- U.dump(ae[ie],'?? HIT:'..tostring(i))
return p,i
for i,ie in pairs(aebound) do
-- U.dump(ae[ie],'?? onBoundary:'..i..':'..ie)
if ae[ie] then
for i,loop in pairs(aloop) do
-- U.dump(loop, '?? for_loop:'..i) --..':'..#loop..':'..tableSize(loop))
local isout,irc
local aedown = {}
-- U.dump(av,'?? pre_loop:'..i)
local ifr,ito
if ib then
-- U.dump('?? on_BOUNDD:'..i..':'..k)
-- if i~=2 or k~=1 then
-- if i~=2 or k~=1 then
-- U.dump(ae, '?? ae:')
-- U.dump(aebound, '?? aebound:')
-- U.dump(ae, '?? ae:')
-- U.dump(aebound, '?? aebound:')
-- end
aebound[#aebound+1] = #ae
-- U.dump(aebound, '?? aebound:')
elseif not U.inRC(b, {base}) then --, nil, true) then
local ie = aebound[ind]
-- U.dump(aebound, '?? on_BOUND:'..k..':'..tostring(U.mod(k,loop))..':'..ind..':'..tostring(p))
av[start+k].p = p
astick[#astick+1] = start+k
-- U.dump(ae[aebound[ie]],'?? onB:'..k..':'..tostring(p)..'>'..ie..':'..ind..':'..(start+k)) --tostring(av[iv].p))
-- update aebound
-- if i == 1 then
-- U.dump(ae, '?? post_CROSS_:'..i..':'..k)
-- U.dump(aebound, '?? post_CROSS_aeb_:'..i..':'..k)
-- U.dump(ae, '?? post_CROSS_:'..i..':'..k)
-- U.dump(aebound, '?? post_CROSS_aeb_:'..i..':'..k)
-- end
aebound[#aebound+1] = #ae
U.dump(ae, '?? ae_pp:')
end
end
U.dump(aebound, '?? on_BOUND_out:'..k)
]]
]]
-- U.dump(ae, '?? AE:')
-- U.dump(aebound, '?? aebound:')
-- U.dump(ae, '?? AE:')
-- U.dump(aebound, '?? aebound:')
-- table.remove(aebound
-- if i == 2 then
-- U.dump(ae, '?? pre_CROSS:'..i..':'..k)
-- U.dump(aebound, '?? pre_CROSS_aeb:'..i..':'..k)
-- U.dump(ae, '?? pre_CROSS:'..i..':'..k)
-- U.dump(aebound, '?? pre_CROSS_aeb:'..i..':'..k)
-- end
local p,ind = crossBoundary(loop,k)
-- U.dump(ae, '?? tobound2_AE:'..i..':'..k..':'..ind) --..':'..(start+k+1))
U.dump(ae[aebound[ind]], '?? tobound2:'..i..':'..k..':'..tostring(p)) --..':'..ind..':'..ifr..':'..isout) --..(start+k+1))
-- U.dump(ae, '?? tobound2_AE:'..i..':'..k..':'..ind) --..':'..(start+k+1))
U.dump(ae[aebound[ind]], '?? tobound2:'..i..':'..k..':'..tostring(p)) --..':'..ind..':'..ifr..':'..isout) --..(start+k+1))
ito = aloopind[i][isout]
ito = aloopind[i][isout]
-- U.dump(aestamp, '?? tobound2:'..i..':'..k..':'..ind..':'..ifr..'>'..ito) --..(start+k+1))
if p then
end
-- U.dump(ae[iv],'?? DDOWN:'..start..':'..k..':'..idupe..':'..#ae)
U.dump(ae[idupe],'?? to_DOWN:')
-- U.dump(ae[iv],'?? DDOWN:'..start..':'..k..':'..idupe..':'..#ae)
U.dump(ae[idupe],'?? to_DOWN:')
edgeDown(idupe)
if i == 2 then
-- U.dump(ae, '?? post_CROSS:'..i..':'..k)
-- U.dump(aebound, '?? post_CROSS_aeb:'..i..':'..k)
-- U.dump(ae, '?? post_CROSS:'..i..':'..k)
-- U.dump(aebound, '?? post_CROSS_aeb:'..i..':'..k)
end
-- isout = nil
-- U.dump(aebound, '?? aebound:')
end
start = start + #loop
-- U.dump(loop, '?? loop_OUT:')
end
end
-- U.dump(av, '?? av_post')
-- U.dump(astick, '?? vSTICK:')
-- U.dump(av, '?? av_post')
-- U.dump(astick, '?? vSTICK:')
-- U.dump(ae, '?? ae_post:')
-- U.dump(astick, '?? vSTICK:')
-- U.dump(ae, '?? ae_post:')
-- for iv,_ in pairs(v.star) do
-- U.dump(forSprouts(v),'?? if_V:'..i)
local asprout = forSprouts(v)
-- if i == 12 then
-- U.dump(v.star, '?? for_star:'..i)
-- U.dump(asprout, '?? for_sprout:'..i)
-- U.dump(v.star, '?? for_star:'..i)
-- U.dump(asprout, '?? for_sprout:'..i)
-- end
-- if i == 12 then
-- U.dump(e, '?? for_eS:'..k)
-- end
local pc,s = U.line2seg(p,av[iv].p,av[e[1]].p,av[e[2]].p,0.00001)
-- U.dump(e,'?? for_dtep:'..k..':'..tostring(p)..'>'..tostring(pc)..':'..tostring(s)..':'..iv) --..':'..tostring((pc-p):dot(p-av[iv].p)))
-- if i == 12 then -- and k == 5 then
-- if i == 12 then -- and k == 5 then
-- U.dump(e,'?? for_12:'..k..':'..tostring(p)..'>'..tostring(pc)..':'..tostring(s)..':'..iv) --..':'..tostring((pc-p):dot(p-av[iv].p)))
-- end
end
-- U.dump(e,'??******* hit: v:'..iv..'>'..i..':'..tostring(d))
-- lo('?? cross_S:'..tostring(s))
if pmi then
-- U.dump(ae[emi],'?? for_MI:'..i..':'..tostring(pmi)..':'..smi)
if smi == 0 then
-- if i == 9 then
-- U.dump(av[#av], '?? to_INS:'..i..':'..#av..':'..emi)
-- U.dump(ae, '?? for_AEINS_pre:'..i..'>'..#av..':'..tableSize(ae)..':'..emi)
-- U.dump(av[#av], '?? to_INS:'..i..':'..#av..':'..emi)
-- U.dump(ae, '?? for_AEINS_pre:'..i..'>'..#av..':'..tableSize(ae)..':'..emi)
-- end
-- if i == 12 then
-- U.dump(av[#av], '?? to_INS:'..i..':'..#av..':'..emi)
-- U.dump(ae, '?? for_AEINS_post:'..tableSize(ae))
-- U.dump(av[#av], '?? to_INS:'..i..':'..#av..':'..emi)
-- U.dump(ae, '?? for_AEINS_post:'..tableSize(ae))
-- U.dump(ae, '?? postINS:')
-- U.dump(ae, '?? for_AEINS_post:'..tableSize(ae))
-- U.dump(ae, '?? postINS:')
-- end
-- U.dump(ae, '?? postins:')
-- U.dump(av[6].star, '?? postins:')
-- U.dump(ae, '?? postins:')
-- U.dump(av[6].star, '?? postins:')
-- U.dump(av[9].star, '?? postins:')
-- U.dump(av[6].star, '?? postins:')
-- U.dump(av[9].star, '?? postins:')
-- return albl
-- if i==9 then -- and emi==5 then
-- U.dump(ae, '?? to_EDGE:'..tostring(smi)..':'..emi)
-- end
end
-- U.dump(ae, '?? ae_post_s:')
albl = {}
end
-- U.dump(aeo, '?? sorted_AEO:')
local pth,map = U.polyStraighten(pth)
-- U.dump(map,'?? straihtned:'..#p..'/'..#pth)
local iseq = {}
]]
-- if dbg then U.dump(av[b].star, '?? star:'..b) end
-- U.dump(av[b].star, '?? stepNext:'..a..'>'..b)
-- if dbg then U.dump(av[b].star, '?? star:'..b) end
-- U.dump(av[b].star, '?? stepNext:'..a..'>'..b)
local ama, ima = math.huge
-- if nia > 3 then break end
-- U.dump(s, '?? for_S:'..ia)
for ib,d in pairs(s) do
path[#path+1] = civ
-- U.dump(aeo, '?? ae_POSTSTEP:'..civ..' n:'..n)
-- break
end
-- U.dump(path, '?? ae_POSTSTEP: n:'..n..':'..tostring(istart==path[#path])..':'..nia)
if path[#path] == istart then
end
-- U.dump(aeo, '?? AEO:'..#apath)
end
end
-- U.dump(apath, '?? APTH:')
-- U.dump(aeo, '?? AEO:')
-- U.dump(apath, '?? APTH:')
-- U.dump(aeo, '?? AEO:')
-------------------------
local an = {-(base[#base]-base[1]):cross(base[2]-base[1]):normalized()}
-- U.dump(base,'??_____________ rcPave:'..tostring(an[1]))
for i,p in pairs(apath) do
local pth,map = U.polyStraighten(pth)
-- U.dump(map,'?? straihtned:'..#p..'/'..#pth)
local iseq = {}
-- an = {vec3(0,0,1)}
-- U.dump(avert, '?? preUV:')
auv = uv4poly(avert, 1) --, nil, true)
auv = uv4poly(avert, 1) --, nil, true)
-- U.dump(auv, '?? AUV:')
M.uvTransform(auv, mrc[1], mrc[2])
-- lo('?? mdata:'..#avert..':'..#auv..':'..#af..':'..#an)
-- U.dump(an, '?? AN:')
end
if dbg then U.dump(mbody, '<< rcPave') end
-- lo('?? ff:'..i)
-- U.dump(e, '?? for_e:'..i)
local step
-- got for circle
-- U.dump(step, '?? step:'..i)
local piv,iv = step[1],step[2]
istart = i+1
U.dump(ae[i], '?? for_i:'..i)
if ae[i].done ~= 0 then
av[start+k+1].p = loop[k+1]
U.dump(iecheck,'?? out_last:'..k..':'..isout..':'..irc)
-- edgeDown(ie)
for j,ie in pairs(iecheck) do
-- U.dump(ae[ie], '?? for_edge:'..j..':'..ie..':'..#ae)
if U.line2seg(U.mod(k+1,loop),U.mod(k,loop),av[ae[ie][1] ].p,av[ae[ie][2] ].p) then
if U.line2seg(U.mod(k+1,loop),U.mod(k,loop),av[ae[ie][1] ].p,av[ae[ie][2] ].p) then
U.dump(ae[ie], '?? hit_ie:'..ie..':'..(start+k))
edgeUp(start+k+1,ae[ie][1])
-- if true then return end
-- dump(apatch, '>> rcPave:'..#aloop)
-- dump(rc, '>> rcPave_hull:')
-- dump(apatch, '>> rcPave:'..#aloop)
-- dump(rc, '>> rcPave_hull:')
-- indrag = true
end
-- U.dump(loop, '?? loop_OUT:')
end
end
-- U.dump(aloopstick, '?? loopstick:')
-- U.dump(aloop, '?? aloop:')
-- U.dump(aloopstick, '?? loopstick:')
-- U.dump(aloop, '?? aloop:')
-- table.remove(v4e[8],1)
-- U.dump(v4e, '?? v4e:')
-- U.dump(e4v, '?? e4v:'..#rc)
-- U.dump(v4e, '?? v4e:')
-- U.dump(e4v, '?? e4v:'..#rc)
-- if true then return end
-- if true then return end
-- U.dump(ae, '?? ae:')
-- original vertices number
U.lo('>>************ forCross:'..tostring(v), true)
-- U.dump(vinfo, '>>************ forCross:'..tostring(v)..':'..#v4e)
end
end
-- if dbg then U.dump(e4v[i], '?? for_E:'..i..':'..tostring(c)) end
-- if dbg then lo('?? for_E:'..i..':'..e4v[i][1].ind..':'..e4v[i][2].ind..':'..tostring(c), true) end
if dbg and c then
-- U.dump(e4v[i], '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e, '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e4v[i], '??+++ for_e:'..i..':'..tostring(c))
-- U.dump(e, '??+++ for_e:'..i..':'..tostring(c))
end
if d == 0 then
if istest then U.dump(e4v[i],'?? on_EDGE:'..i) end
isdupe = true
isend = e4v[i][1].ind
if dbg then U.dump(e4v[i], '??_____________ END1:'..isend) end
elseif (e[2] - cmi):length() < sense then
isend = e4v[i][#e4v[i]].ind
if dbg then U.dump(e4v[i], '??_____________ END2:'..isend) end
else
if isdupe then
if istest then U.dump(e4v[imi], '??__________________ DUPE:'..tostring(cmi)..':'..tostring(imi)) end
v4e[k].isdupe = true
local d = (cmi-ae[imi][1]):length()/(ae[imi][2]-ae[imi][1]):length()
-- U.dump(e4v[imi], '?? v:'..k..' to:'..tostring(d))
e4v[imi][#e4v[imi]+1] = {ind = k, d = d, done = 0}
v4e[k][#v4e[k]+1] = imi
-- U.dump(v4e[k], '?? v___:'..k..' to:'..tostring(d)..':'..imi)
elseif imi then
elseif imi then
-- U.dump(ae[imi], '?? for_cross: k='..k..' ie:'..imi..':'..tostring(p))
-- edges connecting loops
if isend then
-- U.dump(e4v[#e4v], '??********************* new_e4v:'..#v4e..':'..tostring(isend))
end
end
-- U.dump(e4v, '?? e4v_poststem:'..#rc)
-- U.dump(v4e, '?? v4e_poststem:')
-- U.dump(e4v, '?? e4v_poststem:'..#rc)
-- U.dump(v4e, '?? v4e_poststem:')
-- if true then return end
-- if istest then U.dump(e4v, '?? e4v:') end
-- lo('?? v4e_post_stem:'..nv..'>'..#v4e)
-- lo('?? v4e_post_stem:'..nv..'>'..#v4e)
if istest then U.dump(v4e, '?? v4e:'..nv..'>'..#v4e) end
if istest then U.dump(ae, '?? ae:') end
if istest then U.dump(v4e, '?? v4e:'..nv..'>'..#v4e) end
if istest then U.dump(ae, '?? ae:') end
local albl = {}
end
-- U.dump(v4e, '?? av:'..nv)
-- U.dump(estamp, '?? estamp:'..nv)
-- U.dump(v4e, '?? av:'..nv)
-- U.dump(estamp, '?? estamp:'..nv)
-- if true and istest then return {},{},ae,{},albl end
local dbg = false --(n1 == 15 and n2 == 4)
if dbg then U.dump(v4e[n2], '>>__________________________ stepFrom:'..n1..'>'..n2..'/'..ns) end
local astar = {}
for _,ie in ipairs(v4e[n2]) do
if dbg then U.dump(e4v[ie], '??***** for_edge:'..ie) end
for i,n in ipairs(e4v[ie]) do
end
if istest and dbg then U.dump(astar, '?? star:') end
local v = v4e[n2].p - v4e[n1].p
end
-- U.dump(ima, '<< stepFrom:'..tostring(ima[1].ind))
if ima then
-- U.dump(e4v, '?? e4v:'..#rc)
local arc = {}
for i,list in pairs(e4v) do
-- U.dump(list, '??___________________ for_edge:'..i)
-- U.lo('?? for_edge:'..i)
togo = true
-- if istest then U.dump(list, '?? step:'..n.ind..':'..n.d) end
local iprev, inext = n.ind, n.d < 1 and list[k+1].ind or list[k-1].ind
lo('!! ERR_while:'..i..':'..k)
-- U.dump(e4v,'!! ERR_while:'..i..':'..k)
-- U.dump(list,'!! ERR_while:'..i..':'..k)
-- U.dump(e4v,'!! ERR_while:'..i..':'..k)
-- U.dump(list,'!! ERR_while:'..i..':'..k)
break
end
if istest then U.dump(rc, '??<<<<<<< for_rc:') end
if #rc > 2 then
arc[#arc+1] = rc
-- U.dump(rc, '??<<<<<<< for_rc:')
-- togo = false
-- lo('?? for_ARC:'..#arc..':'..ns)
if istest then U.dump(arc, '?? arc:'..#arc..':'..ns) end
--!! table.remove(arc, #arc)
local rc = arc[k]
-- U.dump(rc, '?? for_rc:')
local ifirst
end
-- U.dump(rc, '?? shifted:'..k)
end
end
-- U.dump(rc, '?? cleaned:'..k)
end
end
--U.dump(ast, '??___________________ ast:')
end
-- U.dump(v4e, '?? for_RC:'..#arc)
if istest then U.dump(arc, '?? cleaned:'..#arc..':'..stbase) end
-- U.dump(v4e, '?? for_RC:'..#arc)
if istest then U.dump(arc, '?? cleaned:'..#arc..':'..stbase) end
apath = {}
apath = {}
-- U.dump(arc, '?? cleaned:'..#arc..':'..stbase)
-- if true then return {},{},ae,apath,albl end
-- U.dump(ast, '?? ast:')
-- local u,v = rc[2]-rc[1],rc[4]-rc[1]
end
-- U.dump(av, '?? for_AV:')
-- lo('?? for_start:'..tostring(av[3])..':'..tostring(rc[1])..':'..tostring(rc[3]))
-- arc = {}
-- U.dump(av, '?? for_AV:'..#av)
-- U.dump(arc, '?? for_RC:'..#arc)
-- U.dump(av, '?? for_AV:'..#av)
-- U.dump(arc, '?? for_RC:'..#arc)
-- table.remove(arc, 10)
,(rc[2]-rc[1]):cross(rc[4]-rc[1]), mrc[2])
-- U.dump(mrc, '?? mrc')
if istest then U.dump(auv, '?? AF:'..#af..':'..#auv) end
-- U.dump(mrc, '?? mrc')
if istest then U.dump(auv, '?? AF:'..#af..':'..#auv) end
for i,uv in pairs(auv) do
end
-- U.dump(af, '?? for_AF:'..#af)
-- lo('?? for_AF:'..#af)
-- U.dump(e4v, '?? e4v:')
-- U.dump(apath, '?? apath:')
-- U.dump(e4v, '?? e4v:')
-- U.dump(apath, '?? apath:')
-- lo('<< rcPave: av:'..#av..' af:'..#af..' afhole:'..#afhole..'/'..ns, true)
for i,m in pairs(am) do
-- U.dump(m, '?? for_m:'.._)
if not m.faces or #m.faces == 0 then
if not f.u or not f.v or not f.n then
U.dump(m.faces[_],'!! valid2:'..i..':'.._..':'..#m.faces)
-- U.dump(m.faces[_-1],'!! valid21:'.._..':'..#m.faces)
U.dump(m.faces[_],'!! valid2:'..i..':'.._..':'..#m.faces)
-- U.dump(m.faces[_-1],'!! valid21:'.._..':'..#m.faces)
-- if not f.u and #m.uvs>0 then
if not d.u or not d.v then
U.dump(d,'!! valid41_uvs:'..i..':'..j)
return false
-- data = {data[1]}
-- U.dump(data, '??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mU:',nil,2)
om:createMesh({data})
end
-- U.dump(loop, '?? for_LOOP:')
if #loop>2 then
end
-- U.dump(awloop,'?? awLOOP:'..#awloop)
-- awloop = {}
-- if true then return end
-- U.dump(mbody.verts, '?? MB_VERTS:'..tostring(pmi))
-- order verts
end)
-- U.dump(av, '?? AV:')
-- if true then return end
-- if true then return end
-- U.dump(ap, '?? AFPOS:')
-- M.out.aset = {{set=ap,c={1,1,0}}}
end
-- U.dump(anorm, '?? v_vs_n:'..#mbody.verts..':'..#anorm)
for i,f in pairs(mbody.faces) do
--TODO:dependency of normals on vertices
-- U.dump(aloop)
-- lo('??^^^^^^^^^^^^^^^^^^^^^^^^^^^ frameSpline.for_LOOP:'..#aloop..':'..N)
mbody.normals[i] = vec3(0,0,1)
-- U.dump(aseq, '!! ERR_WRONG_LOOP:'..i..':'..#aseq)
-- U.toFile(sarg, {'tmp'}, 'fsplinejson')
end
-- U.dump(loop,'?? for_NORM:'.._..':'..tostring(norm))
end
mbody.normals = anorm
-- U.dump(mbody.normals, '?? fSpline_norm:'..#mbody.faces..':'..#mbody.verts)
-- for i=2,#mbody.normals
U.pop(acand,cv)
-- U.dump(acand, '?? forCAND:'..cv)
-- lo('?? acand:'..#acand)
end
-- U.dump(abag, '?? aBAG:'..N)
-- for i,bag in pairs(abag) do
end
-- U.dump(m.verts, '?? verts:')
-- U.dump(w4v, '?? AVERT:'..tableSize(w4v)..'/'..#avert..':'..#aface)
-- U.dump(m.verts, '?? verts:')
-- U.dump(w4v, '?? AVERT:'..tableSize(w4v)..'/'..#avert..':'..#aface)
-- U.dump(aface, '?? AFACE:')
-- U.dump(w4v, '?? AVERT:'..tableSize(w4v)..'/'..#avert..':'..#aface)
-- U.dump(aface, '?? AFACE:')
-- if true then return end
lo('?? astar:'..#astar)
-- U.dump(astar, '?? ASTAR:')
-- if true then return {} end
U.pop(acand,cv)
-- U.dump(acand, '?? forCAND:'..cv)
-- lo('?? acand:'..#acand)
end
-- U.dump(abag, '?? aBAG:'..N)
-- for i,bag in pairs(abag) do
--[[
U.dump(fbag,'?? fbag:'..#fbag)
if true then return {} end
table.sort(set)
-- dump(set, '?? for_SET:'..i)
local hit
]]
-- U.dump(abag, '?? ABAG:')
-- U.dump(aface, '?? AFACE:')
-- U.dump(abag, '?? ABAG:')
-- U.dump(aface, '?? AFACE:')
-- U.dump(fbag, '?? AFBAG:')
-- U.dump(aface, '?? AFACE:')
-- U.dump(fbag, '?? AFBAG:')
local cf = aface[dedge[e][1]]
-- U.dump(cf.ae, '?? fnext:'..e..':'..cfi)
-- check smoothness
local asurf = {}
-- U.dump(b,'??============= for_BAG:')
dedge = {}
end
-- U.dump(dedge, '?? dEDGE:'..i)
-- if true then return {} end
fnext(f)
-- U.dump(acand,'?? if_CAND:'..f)
--[[
acand = {}
U.dump(asurf, '?? surf_DUMP:')
end
acand = {}
-- U.dump(asurf, '?? surf_DUMP:')
-- U.dump(surf,'?? for_SURF:')
-- U.dump(asurf, '?? surf_DUMP:')
-- U.dump(surf,'?? for_SURF:')
break
-- asurf[#asurf+1] = surf
-- U.dump(asurf,'?? aSURF:'..N)
-- U.dump(dedge,'?? for_N:'..N)
-- U.dump(asurf,'?? aSURF:'..N)
-- U.dump(dedge,'?? for_N:'..N)
-- break
end
-- U.dump(dedge,'?? dEDGE:'..#abag)
-- U.dump(aface, '?? AFACE:')
-- U.dump(dedge,'?? dEDGE:'..#abag)
-- U.dump(aface, '?? AFACE:')
-- eat out surfaces
local s = U.v2stamp((av[aface[i+1].v]-av[aface[i].v]):cross(av[aface[i+2].v]-av[aface[i].v]):normalized(),2)
U.dump(aface[i], '?? for_face:'..i..':'..s) --..':'..U.v2stamp(vec3(1.122421432,2,3)))
if not dnorm[s] then dnorm[s] = {} end
]]
-- U.dump(dnorm, '?? forPlate:')
lo('<< forPlate:'..#fbag..':'..#bag4surf)
lo('<< forPlate:'..#fbag..':'..#bag4surf)
-- U.dump(bag4surf, '<< forPlate:'..#fbag)
-- if true then return {} end
-- lo('?? joint:'..#a.aiv..':'..#a.aif..':'..#b.aiv..':'..#b.aif)
-- U.dump(a.aiv,'?? for_AIV')
-- U.dump(a,'?? joint_a:',nil,2)
-- U.dump(a.aiv,'?? for_AIV')
-- U.dump(a,'?? joint_a:',nil,2)
-- U.dump(b,'?? joint_b:',nil,2)
-- U.dump(a,'?? joint_a:',nil,2)
-- U.dump(b,'?? joint_b:',nil,2)
if dbg then
if dbg then
U.dump(fmi, '?? joint_HIT:'..dmi..':'..tostring(a.m.verts[imi]))
end
-- lo('?? joint_av:'..#aiv)
-- U.dump(av, '?? for_VATT:'..i..'>'..j)
-- ajoint[U.stamp({i,j},true)] = av
lo('>> forJoint:'..#fbag)
U.dump(fbag[1], '?? FB1:')
local dbg = true
end)
-- U.dump(b.af, '?? AF:'..i)
end
if dbg and p == 20 then
U.dump(fmi.av, '?? ang:'..t..':'..ang..':'..tostring(m.verts[p]))
list[#list+1] = p -- m.verts[p]
if dbg and p == 20 then
U.dump(fmi.av, '?? ang:'..t..':'..ang..':'..tostring(m.verts[p]))
list[#list+1] = p -- m.verts[p]
-- lo('?? ang:'..t..':'..ang) --..':'..tostring(m.verts[p]))
U.dump(fmi.av,'?? ang:'..t..':'..ang..':'..tostring(m.verts[p]))
end
]]
-- U.dump(av, '?? for_VATT:'..i..'>'..j)
ajoint[U.stamp({i,j},true)] = av
local mat = daedata.dgeo[m.key].mat
-- dump(mat.c,'?? for_DS:'..i..':'..ds..':'..tostring(m.key)..':'..tostring(mat.c)) --..(#am - 1)..':'..(i-(#am - 1)/2-1)) --..':'..ds)
-- colorOn(mat.body,{mat.c[1],mat.c[2],mat.c[3],0.5+0.5*math.abs(val/10)})
if not indrag then
U.dump(o, '?? for_LABEL:')
Render.label(o.list, o.c)
@/lua/vehicle/controller/tech/tyreBarrier.lua
local pos, vel = obj:getPosition(), obj:getVelocity()
dump("[Preamble phase]: current vehicle velocity: " .. vel:length() * 3.6)
if (pos - targetStartPos):squaredLength() < distToStartTolSq then
isPreamble, time = false, 0.0
dump("Start position reached [preamble phase complete - moving on to phase 2]...")
end
if time > testDuration then
dump("Test complete!")
if hasDataBeenWritten == false then
@/lua/common/utils/calltracer.lua
local function save(filename)
--dump(nodes)
local txt = ''
@/lua/ge/extensions/editor/gen/region.lua
local function cornerPrev(c)
-- U.dump(c, '>> cornerPrev:')
local dir = c.dir
end
-- U.dump(push, '?? pre_ret: da:'..tostring(da)..' db:'..tostring(db))
if not da then da = math.huge end
local function p2side(p, side, start, dbg)
-- U.dump(side, '>> p2side:'..tostring(p)..':'..start)
if not start then start = side.fr end
if dbg then
U.dump(side, '?? p2side:'..start..':'..side.dir..':'..side.fr..'>'..side.to)
end
pos = vp:cross(p - anode[ni]).z > 0 and -1 or 1
-- U.dump(side, '?? for_last:'..d..':'..pos..':'..dprev..' ni:'..ni)
if pos < 0 then
if not mrg then mrg = margin end
U.dump(side, '>> dist2base:'..d)
local n2d = D.node2edge(scenetree.findObjectById(adec[side.rd].id))
local wd = anobj[sto.fr].width
U.dump(sfr, '>> forCorner:'..wd)
local anode = adec[sto.rd].list
acLen[#acLen + 1] = L
U.dump(side, '>>--------------- seed: L='..tostring(L)..' dma:'..tostring(dma)..':'..tostring(tp)..' nbase:'..#abase..' nside:'..#aswitch..':'..#base..':'..tostring(_DBG))
-- lo('?? for_length:'..tostring(dn2d[side.rd][side.dir>0 and side.to or side.fr].d))
-- lo('?? for_seed:'..)
-- U.dump(n2d, '?? anode:'..L)
-- out.acyan = {p}
end
-- U.dump(base, '?? for_base:'..#abase)
depthma = forDepth(base[#base-1],base[#base]) --, true)
depthma = forDepth(base[#base-1],base[#base]) --, true)
-- U.dump(base, '?? for_DEPTH:'..tostring(depthma)..':'..sideWidth(side, ni))
-- out.acyan = {base[#base-1], base[#base]}
abound[#abase+1] = {v,w}
-- U.dump(abound, '?? abound:'..#abound)
local prd,ni,s = p2side(p, side)
-- U.dump(side, '?? for_p:'..i..':'..j..':'..tostring(p)..':'..(p - prd):length()..'/'..d)
if (p - prd):length() > d then
if #agreen == 2 then
-- U.dump(agreen, '?? fromDepth_DONE:')
if not agreen[1].p then
if not parity then parity = 1 end
U.dump(side, '>> sidePush:'..parity..':'..#aswitch)
-- out.ayel = {}
tonext = aswitch[k] + 1
U.dump(aswitch, '??------------------------------------ switching:'..i..'>'..tonext)
break
-- tonext = i + 5*step
-- U.dump(aswitch, '??------------------------------------ switching:'..i..'>'..tonext)
goto cont
if parity == -1 then
U.dump(side, '?? preDIST:'..tostring(corner)..':'..ni..':'..(ni-side.dir))
if ni == side.fr then --and s == 1 then
-- dir = (prd - ppre):dot(v) > 0 and 1 or -1
-- U.dump(side, '?? for_CORNER:'..tostring(ni)..':'..side.dir..':'..s)
-- out.acyan = {corner}
if not parity then parity = 1 end
-- U.dump(sfr, '>> branchPush:'..parity)
-- if not dist then dist = margin + anobj[ni].width/2 + mm_depth[2] end
local last = side.dir < 0 and n2d[side.fr].d or 0
-- U.dump(side,'?? forLimit:'..ni..':'..tostring(node_dist[ni - side.dir])..':'..tostring(node_dist[ni]))
if ni - side.dir < #node_dist then
sideprev = {rd = stem.rdi, fr = fr, to = stem.fr, dir = stem.fr>fr and 1 or -1}
U.dump(sideprev, '?? IF_CORNER:')
local anobjprev = editor.getNodes(scenetree.findObjectById(adec[sideprev.rd].id))
-- TODO: check other sides
-- U.dump(sideprev, '?? sprev:')
local anthem = editor.getNodes(scenetree.findObjectById(adec[sideprev.rd].id))
local function pave(asd)
U.dump(aside, '>> pave:')
if asd then aside = asd end
local side = aside[i]
U.dump(side, '??****************** SIDE:'..i..'/'..#aside..':'..aside[i].rd..':'..#abase)
U.dump(adec[aside[i].rd])
U.dump(side, '??****************** SIDE:'..i..'/'..#aside..':'..aside[i].rd..':'..#abase)
U.dump(adec[aside[i].rd])
n2d = D.node2edge(scenetree.findObjectById(adec[side.rd].id), true)
if pa then
U.dump(side, '?? for_dma:'..i..':'..tostring(pa))
-- out.ayel = {pa}
-- U.dump(aside[(i - 2) % #aside + 1], '?? for_CC:'..tostring(corner)..':'..tostring(dma))
--!!
end
-- U.dump(base, '?? BASE:'..#abase)
-- U.dump(abound, '?? ABOUND:'..#abase)
-- U.dump(base, '?? BASE:'..#abase)
-- U.dump(abound, '?? ABOUND:'..#abase)
if not base or #base < 4 then
end
-- U.dump(side, '?? for_curv:'..i..':'..n..' inprev:'..inprev..' curv:'..curv)
if curv < 0 then
-- local ppp,ni,s = p2side(abase[#abase][1], aside[4], aside[4].fr)
-- U.dump(aside[4], '?? for_s:'..ni..':'..s..':'..(n2d[aside[4].fr].d - n2d[7].d))
-- out.awhite = {abase[#abase][1], ppp}
-- out.awhite = {ppp}
-- U.dump(n2d, '?? DMA:'..tostring(dma)..':'..tostring(ni)..':'..tostring(s)..':'..(n2d[side.fr].d - n2d[ni].d))
-- dma = 130
dma = d
U.dump(aside[i+1], '?? for_PRD:'..tostring(prd)..' dma:'..tostring(dma))
]]
margin + anobj[side.to].width/2 + mm_depth[2], -1)
U.dump(side, '??__________ pushed_for_1st:'..tostring(p))
local prd = p2side(p, side)
local v = forStem(side, 0)
U.dump(v, '?? for_PREV:')
-- if true then return end
local stem = cornerPrev(side)
U.dump(stem, '?? stem:'..#aside)
local fr = stem.ndi > stem.fr and #adec[stem.rdi].list or 1
margin + anobj[side.fr].width/2 + mm_depth[2])
-- U.dump(sideprev, '?? sideprev:'..(p - anode[side.fr]):dot(forStem(side, 0)))
-- out.ayel = {p}
-- local sprev = {rd = stem.rdi, to = k, fr = fr, dir = (k > fr and 1 or -1)}
-- U.dump(sprev, '?? cprev:')
-- local p = branchPush(cprev, side)
-- local L = W.out.L
-- U.dump(across[rmi], '??____________ mi: nmi='..nmi..' dmi:'..dmi..' rmi:'..tostring(rmi)) --..':'..tostring(across[rmi])) --tostring(adec[rmi].list[nmi])..':'..tableSize(across)) --..':'..tostring(adec[rmi].list[nmi])..':'..tostring(adec[rmi].list[nmi+1])..':'..tostring(p))
-- local grid = 10
table.sort(akey)
-- U.dump(akey, '?? akey:'..nmi)
local ib,ie
end
-- U.dump(akey, '?? sorted:'..dir..':'..ib..'>'..ie)
local ri,ni = c.rd,c.to
-- U.dump(across[ri][ni], '>> cornerNext:'..ri..':'..ni..' dir:'..dir)
local astem,us = U.clone(across[ri][ni])
local star = U.forStar(astem, adec)
-- U.dump(star, '?? star:'..#star..':'..dir)
for i,s in pairs(star) do
-- U.dump(s, '?? for_stem:'..i)
if s.rdi == ri and s.ndi == s.fr + dir then
if s.rdi == ri and s.ndi == s.fr + dir then
-- U.dump(s, '?? for_nxt:'..i)
-- take prev branch
dn2d[rmi] = D.node2edge(scenetree.findObjectById(adec[rmi].id))
-- U.dump(acorner, '?? first_side:'..rmi)
-- if true then return end
local stem = cornerNext(acorner[#acorner], -dir)
-- U.dump(stem,'?? next_stem:'..i)
-- if i > 2 then return end
end
-- U.dump(stem, '?? nxt:'..i..':'..stem.rdi)
-- U.dump(across[stem.rdi], '?? cross:'..i)
-- U.dump(stem, '?? nxt:'..i..':'..stem.rdi)
-- U.dump(across[stem.rdi], '?? cross:'..i)
akey = {}
dir = stem.ndi - stem.fr
-- U.dump(akey, '?? sorted:'..dir..':'..stem.fr)
local ind = U.index(akey, stem.fr)[1] --table.index_of(akey, stem.ndi)
U.dump(acorner, '??________ acorner:'..#acorner)
out.avedit = {}
end
-- U.dump(across[1][1], '?? pop:'..tableSize(across))
D = odec
local p = cpoint -- cameraMouseRayCast().pos
-- U.dump(adec[133], '?? pop_adec:'..tableSize(adec)..':'..tostring(p))
-- out.avedit = {}
-- local L = W.out.L
U.dump(across[rmi], '??____________ mi: nmi='..nmi..' dmi:'..dmi..' rmi:'..tostring(rmi)..':'..tostring(adec[rmi].list[nmi])..':'..tableSize(across)) --..':'..tostring(adec[rmi].list[nmi])..':'..tostring(adec[rmi].list[nmi+1])..':'..tostring(p))
-- local grid = 10
table.sort(akey)
-- U.dump(akey, '?? akey:'..nmi)
local ib,ie
end
-- U.dump(akey, '?? sorted:'..dir..':'..ib..'>'..ie)
local ri,ni = c.rd,c.to
-- U.dump(across[ri][ni], '>> cornerNext:'..ri..':'..ni..' dir:'..dir)
local astem,us = U.clone(across[ri][ni])
local star = U.forStar(astem, adec)
-- U.dump(star, '?? star:'..#star..':'..dir)
for i,s in pairs(star) do
-- U.dump(s, '?? for_stem:'..i)
if s.rdi == ri and s.ndi == s.fr + dir then
if s.rdi == ri and s.ndi == s.fr + dir then
-- U.dump(s, '?? for_nxt:'..i)
-- take prev branch
dn2d[rmi] = D.node2edge(scenetree.findObjectById(adec[rmi].id))
U.dump(acorner, '?? first_side:'..rmi)
-- if true then return end
local stem = cornerNext(acorner[#acorner], -dir)
-- U.dump(stem,'?? next_stem:'..i)
-- if i > 2 then return end
end
-- U.dump(stem, '?? nxt:'..i..':'..stem.rdi)
-- U.dump(across[stem.rdi], '?? cross:'..i)
-- U.dump(stem, '?? nxt:'..i..':'..stem.rdi)
-- U.dump(across[stem.rdi], '?? cross:'..i)
akey = {}
dir = stem.ndi - stem.fr
-- U.dump(akey, '?? sorted:'..dir..':'..stem.fr)
local ind = U.index(akey, stem.fr)[1] --table.index_of(akey, stem.ndi)
U.dump(acorner, '??________ acorner:'..#acorner)
out.avedit = {}
lo('?? paved:'..#abase)
-- U.dump(across[i][j], '?? sorted:'..i..':'..j)
else
else
U.dump(adec[rmi], '!! NO_CROSS:'..tostring(rmi)..':'..tostring(n))
-- U.dump(nil, '?? ij:'..i..':'..j..':'..tostring(across[i]))
U.dump(adec[rmi], '!! NO_CROSS:'..tostring(rmi)..':'..tostring(n))
-- U.dump(nil, '?? ij:'..i..':'..j..':'..tostring(across[i]))
end
-- U.dump(aref, '?? updated:'..tostring(aref))
-- U.dump(adec, '?? adec:'..#adec)
-- U.dump(aref, '?? updated:'..tostring(aref))
-- U.dump(adec, '?? adec:'..#adec)
end
lo('>>++++++++__________ conform:'..L..':'..tableSize(adec)..':'..tableSize(aref)..':'..#aref..':'..tostring(U._mode))
-- U.dump(aref, '?? AREF:')
-- if tableSize(adec)
out.avedit = {}
U.dump(desc.afloor[1].base, '>> conform: pos = '..tostring(desc.pos)..' c:'..tostring(c)..' hbase:'..hbase..':'..tostring(indrag)) --..':'..desc.id)
out.apoint = {c + vec3(0, 0, hbase + W.forHeight(desc.afloor) + 0.0)}
end
-- U.dump(agrid, '?? AGRID:')
-- if i > 100 and j > 100 then
-- if i > 100 and j > 100 then
-- U.dump(aref[i][j],'?? for_agrid:'..i..':'..j..':'..#agrid..':'..x..':'..y)
-- U.dump(agrid)
-- U.dump(aref[i][j],'?? for_agrid:'..i..':'..j..':'..#agrid..':'..x..':'..y)
-- U.dump(agrid)
-- end
-- if ij[1] == 101 and ij[2] == 101 then
-- U.dump(aref[ij[1]][ij[2]], '?? CHECK:'..tostring(hasnodes))
-- end
if dec[2] < #rd then nto = nto + 1 end
-- U.dump(dec, '?? for_dec:'..ind..':'..nfr..':'..nto)
for k = nfr,nto-1 do
end
-- U.dump(aref[ij[1]][ij[2]], '?? for_ref:'..ij[1]..':'..ij[2])
end
-- end
-- U.dump(desc.afloor[1].awall[1].df, '?? DF:')
-- W.forestClean(desc)
if #asel > 0 and desc.id == asel[#asel] then
U.dump(adec, '?? LAST:'..tostring(N.cid)) --adec[17].id)
D.ter2road(nil, N.cid)
@/lua/ge/extensions/editor/api/preferencesRegistry.lua
editor.logWarn("Preferences: Could not set default value for: `" .. path .. "`")
dump(val)
end
editor.logWarn("Preferences: Could not set actual default value (it's nil) for: `" .. path .. "`")
dump(val)
end
@/lua/ge/extensions/editor/resourceChecker.lua
end
if FS:fileExists(res) then dump(FS:stat(res)) else log('E', '', 'Path :'..tostring(res)..' does not exist' ) end
im.CloseCurrentPopup()
@/lua/ge/extensions/flowgraph/nodes/vehicle/getPowertrainData.lua
if veh then
core_vehicleBridge.requestValue(veh, function(val) dump(val) dumpz(self, 1) self.receivedInfo = val.result end,'powertrainDevice', self.pinIn.device.value, self.pinIn.property.value)
self:setDurationState('started')
@/lua/ge/extensions/ui/topBar.lua
M.onGameStateUpdate = function(state)
-- dump("ui_topbar: onGameStateUpdate ", state)
M.requestGameState()
M.onUiChangedState = function(state)
-- dump("ui_topbar: onUiChangedState ", state)
end
M.onUIStateTriggered = function(state, opened, stack)
-- dump("ui_topbar: onUIStateTriggered ", {state, opened, stack})
@/lua/ge/extensions/editor/flowgraph/main.lua
jsonWriteFile(fn, scenarioJson, true, 20)
--dump("write to " .. fn)
end, {{"Node graph Files",".flow.json"}}, false, self.fgEditor.lastOpenedFolder)
if im.Begin(name..'##'..gr.id, gr.showTab, windowFlags) then
--dump(im.GetWindowDrawList())
if not focussed and ((not self.mgr.graph) or (gr.id ~= self.mgr.graph.id)) and im.IsWindowFocused() then
if node.id == duplicateId then
dump("Node " .. node.name .. "/"..node.id.." in " .. node.graph:getLocation(true))
end
if gr.id == duplicateId then
dump("Graph "..gr.id.."/ in " .. gr:getLocation(true))
end
if im.Button("All OK :) " .. table.getn(ids)) then
dump(ids)
end
table.sort(nIds[b])
dump(string.format("%ders: %s", (b-1)*100, table.concat(nIds[b],", ")))
end
@/lua/ge/extensions/editor/raceEditor/testing.lua
if im.Button("State") then
dump(self.race.states[self.race.vehIds[1]])
end
@/lua/vehicle/controller/tirePressureControl.lua
registerQuickAccess()
--dump(wheelGroups)
end
@/lua/ge/extensions/flowgraph/nodes/ui/threeElementSelect.lua
self.open = true
-- dump("opening dialogue!")
@/lua/ge/client/lighting.lua
-- local files = FS:findFiles('/core/scripts/client/lighting/', 'init.cs', 1, true, false)
-- dump(files)
-- for _,filepath in ipairs(files) do
local files = FS:findFiles('lua/ge/client/lighting/', 'init.lua', 1, true, false)
-- dump(files)
for _,filepath in ipairs(files) do
-- local files = FS:findFiles('/core/scripts/client/lighting/', 'init.cs', 1, true, false)
-- dump(files)
-- for _,filepath in ipairs(files) do
@/lua/vehicle/controller/bypassDampers.lua
--dump(dampers)
--dump(beamZones)
--dump(dampers)
--dump(beamZones)
--dump(damperZones)
--dump(beamZones)
--dump(damperZones)
end
@/lua/ge/extensions/career/modules/delivery/generator.lua
print("no location!")
dump(loc)
return nil
for _, item in ipairs(getDeliveryParcelTemplates()) do
dump(item.id, item.logisticType)
end
destination = {type = "multi", destinations = {}}
--dump(typesLookup)
for _, f in ipairs(facilities) do
local destination = {type = "multi", destinations = {}}
--dump(typesLookup)
for _, f in ipairs(facilities) do
local match = false
--dump(fac.logisticTypeLookup)
for key, _ in pairs(generator.logisticTypesLookup) do
fac.progress = loadData.facilities[fac.id].progress
--dump(loadData.facilities[fac.id])
end
@/lua/ge/extensions/editor/forestEditor.lua
print("###### Forest Brushes #####")
dump(var.forestBrushes)
print("###### Forest Brushes End #####")
print("###### Forest Brushes Map #####")
dump(var.forestBrushesMap)
print("###### Forest Brushes Map End #####")
print("ForestBrushGroup")
dump(getmetatable(var.forestBrushGroup))
end
@/lua/ge/extensions/flowgraph/nodes/vehicle/spawnVehicle.lua
--dump("id is : "..self.veh:getId())
self._dontDelete = self.pinIn.keepVehicle.value or false
elseif self.state == 2 then
--dump(self.id .. dumps(self.veh))
if self.mgr.modules.vehicle:getVehicle(self.spawnedObjectId).ready then
@/lua/ge/extensions/core/online.lua
-- example usage:
-- core_online.apiCall('s1/v1/getMods?query=&order_by=&order=&page=1', function(...) dump(...) end)
@/lua/ge/extensions/editor/flowgraph/overview.lua
print("-- Current child path --")
dump(self.mgr.graph:getChildPosition())
print("-- Current graphs children: --")
@/lua/ge/extensions/tech/utils.lua
local output = outputs[M.secondViewOutput].region
dump(output)
local camNodeID, rightHandDrive = core_camera.getDriverData(getPlayerVehicle(0))
@/lua/common/utils/wsUtils.lua
local events = server:getPeerEvents()
--dump({'server events: ', events})
local res = false
events = client:getPeerEvents()
--dump({'client events: ', events})
res = false
@/lua/ge/extensions/editor/gen/exp_solidflex.lua
-- U.dump(editor.editModes, '?? EM:')
m = W.build(aa)
-- U.dump(m,'?? for_M:')
local id,om = M.meshUp({m},'tst', scenetree.findObject('edit'))
-- for i,a in pairs(ac) do
-- U.dump(avp,'??----------- NEXT:'..i..':'..aind[i])
local w = an[#an]
-- local vb = av[#av-1-(1-aind[i])/2]
-- U.dump(avp, '?? for_VB_W:'..i..' vb:'..tostring(vb)..' w:'..tostring(w))
local u = -aind[i]*(vb - av[#av]):cross(w):normalized()
aax[#aax + 1] = avp
-- U.dump(aax[#aax], '?? aax:')
-- U.dump(aax[#aax-1], '?? aax-1:')
-- U.dump(aax[#aax], '?? aax:')
-- U.dump(aax[#aax-1], '?? aax-1:')
-- U.dump(avp, '?? for_U_AVP:'..i..' u:'..tostring(u))
-- U.dump(aax[#aax-1], '?? aax-1:')
-- U.dump(avp, '?? for_U_AVP:'..i..' u:'..tostring(u))
-- av[#av+1] = (av[#av] + vb)/2 + (u*math.cos(ac[i]) + w*math.sin(ac[i]))*ah[i]
-- lo('?? if_AV:'..i..' w:'..tostring(w)..' u:'..tostring(u)..':'..tostring(an[#an]))
-- U.dump(av, '?? av:')
-- U.dump(af, '?? AF:')
-- U.dump(av, '?? av:')
-- U.dump(af, '?? AF:')
-- av[#av+1] =
an[0] = nil
-- U.dump(aax, '?? build:'..tostring(av[aax[#aax][1][2]])..':'..tostring(av[#av]))
segpick = {
-- table.remove(an,0)
-- U.dump(an, '?? for_AN:')
if not cpick then
-- m.verts[cvneigh]:tgt[1]
-- U.dump(list, '?? loss:')
-- lo('>> loss:')
table.insert(list, 1, vec3(0,0,0))
-- U.dump(list, '<< loss:')
local m = build(cac)
-- U.dump(aax,'?? aax:'..#aax)
-- U.dump(aax[#aax], '?? AAX:')
-- U.dump(aax,'?? aax:'..#aax)
-- U.dump(aax[#aax], '?? AAX:')
local ax = {aax[i+1][1][1],aax[i+1][2][1]}
m = build(aa)
-- U.dump(m,'?? for_M:')
local id,om = M.meshUp({m},'tst', scenetree.findObject('edit'))
end)
U.dump(de, '?? edge:'..i..':'..dedge[i])
end
]]
-- U.dump(dedge,'?? DEDGE:')
m = build(cac)
-- U.dump(aax,'?? aax:'..#aax)
-- U.dump(aax[#aax], '?? AAX:')
-- U.dump(aax,'?? aax:'..#aax)
-- U.dump(aax[#aax], '?? AAX:')
local ax = {aax[2][1][1],aax[2][2][1]}
m = build(ac)
U.dump(m.verts, '?? for_L:'..L..'>'..cL)
U.out.aset[1] = {set={tgt},c={0,1,0}}
-- U.dump(list, '?? for_LIST:')
local function loss(ac)
-- U.dump(list, '?? loss:')
-- lo('>> loss:')
table.insert(list, 1, vec3(0,0,0))
-- U.dump(list, '<< loss:')
body:createMesh({{m}})
-- U.dump(aax, '?? to_BUILD:'..i)
dedge = {}
if false and cvover then
-- U.dump(aax,'!! to_PIN:'..cvover)
if cvneigh == cvover then
end
-- U.dump(m.verts, '?? for_L:'..L..'>'..cL)
-- U.out.aset[3] = {set=tgt, c={1,0,1,0.2}}
body:createMesh({{m}})
-- U.dump(aax, '?? to_BUILD:'..i)
dedge = {}
dedge[#dedge+1] = U.stamp({aax[#aax][2][2],#m.verts})
-- U.dump(aax[#aax], '?? elast:')
break
if cvneigh then
U.dump(U.out.aset[1].set, '?? set_yel:'..tostring(m.verts[cvneigh]))
end
@/lua/ge/extensions/flowgraph/nodes/gameplay/sites/posInZone.lua
else
dump("No zone data!")
end
@/lua/vehicle/electrics.lua
--dump(customValues)
@/lua/ge/extensions/editor/gen/exp_frame.lua
-- lo('?? build:'..tostring(g))
-- U.dump(ac, '?? AC:')
end
lo('?? to_COMP:'..#ac..':'..#sac)
U.dump(sac,'?? ac_FR:')
local taa = {}
end
-- U.dump(taa, '?? tAA00000:'..#taa)
U.dump(aa,'?? ac_AA:')
-- U.dump(taa, '?? tAA00000:'..#taa)
U.dump(aa,'?? ac_AA:')
U.dump(ac,'?? ac_TO:')
else
local i = 1
-- U.dump(body,'>> build:'..#ac..':'..cfix)
for k,d in pairs(body) do
-- U.dump(dnode, '?? nodes:')
--[[
if ind and ind[2]>9 and ind[2]<13 then
-- U.dump(body.femur_r.hist,'?? if_HIST:'..ind[2])
ac = body.femur_r.hist[1]
if not ind and nmove % ndump == 1 then
-- U.dump(dw, '??______ W_DUMP:'..nmove)
end
-- if not ind then
-- U.dump(ac,'??^^^^^^^^^^^^^^^^^^^ loss_NI:'..tostring(g))
-- end
-- sc[1][sc[2]] = sc[3]
-- U.dump(body.femur_r, '?? body_REST:')
--?? if _dbg
local function step(ac, i, s)
-- U.dump(ac,'>> ef.step:'..i)
local cac = deepcopy(ac)
local obj = U.fromFile('/tmp/eframe/'..state..'/frame.json')
-- U.dump(obj, '?? from_file:'..state)
body = obj.body
end
U.dump(afix, '?? afix_a:'..#aa)
L = loss(aa)
-- cL,L,cac = AI.go2(aa, loss, step, epo/2, 0.01, afix)
U.dump(cac,'?? for_L2:'..tostring(cL))
-- render
return
-- U.dump(adw[key], '?? ADW:')
end
-- cL,L,cac = AI.go2(aa, loss, step, epo/2, 0.01, afix)
-- U.dump(cac,'?? for_L2:'..tostring(cL))
render()
if (L-cL)/cL < 0.0005 and nmove > 0 then
-- U.dump(aa, '?? for_AA:'..((L-cL)/cL)..':'..nmove)
-- U.dump(dnode, '?? for_ANODE:')
-- U.dump(aa, '?? for_AA:'..((L-cL)/cL)..':'..nmove)
-- U.dump(dnode, '?? for_ANODE:')
local smove = cmove
,{'tmp','eframe'}, 'frame.json')
U.dump(dnode,'?? DONE:'..nStep..':'..nmove..':'..tostring(dmove[smove].ptarget))
end
,{'tmp','eframe'}, 'frame.json')
U.dump(dnode,'?? state_DUMP:'..nStep..':'..nmove..':'..tostring(dmove[cmove].ptarget))
smove = cmove
-- if im.IsKeyPressed(im.GetKeyIndex(im.Key_Space)) then
U.dump(dw, '>>>> DW:'..nmove..' L:'..L)
end
@/lua/vehicle/electricsCustomValueParser.lua
--dump(customElectricsEnv)
end
end
--dump(customElectricsEnv.electrics)
end
--print("resetCustomValues")
--dump(customDefaultValues)
for electricsName, value in pairs(customDefaultValues) do
--print("base env")
--dump(customElectricsEnv)
--print("customValueData")
--dump(customValueData)
--print("customDefaultValues")
--dump(customDefaultValues)
--print("customValueUpdateStrings")
--dump(customValueUpdateStrings)
--print("customValueUpdates")
--dump(customValueUpdates)
--print("customValueUpdateString")
--dump(customValueUpdateString)
local customValuesFunc, message = load(customValueUpdateString, nil, "t", customElectricsEnv)
@/lua/ge/extensions/ui/liveryEditor/tools/transform.lua
M.cancelStamp = function()
dump("cancelStamp")
local layerUid = uiSelectionApi.getFirstSelectedLayer()
M.setScale = function(scaleX, scaleY)
dump("tool_transform_setScale", scaleX, scaleY)
uiTools.doOperation(function(layer, scaleX, scaleY)
@/lua/ge/extensions/flowgraph/builder.lua
--print("...")
--dump(self.inputBeginPos.y)
--dump(endPos.y)
--dump(self.inputBeginPos.y)
--dump(endPos.y)
self.noInputPin = endPos.y <= self.inputBeginPos.y+10
@/lua/console/bananabench-json.lua
--dump(args)
local res = bench.physics()
--dump(res)
jsonWriteFile(outputFilename, res, true)
@/lua/ge/extensions/core/vehicles.lua
local model = getModel(modelName)
-- dump(model.configs)
if model.configs and not tableIsEmpty(model.configs) then
else
-- dump(config)
configList[config.model_key .. '_' .. config.key] = config
local function _replaceVehicle(modelName, config, state, localOptions, level)
--dump("replaceVehicle: ", model, opt, otherVeh)
-- Get the other collection's vehicles
end
-- dump(design)
if not design or not design.data then
@/lua/ge/extensions/campaign/campaigns.lua
campaign.state.activeSubsection = ownerSubsection.key
--dump(location)
--dump(campaign)
campaign_campaignsLoader.saveCampaign(campaign)
for _,entry in ipairs(achievement.requires) do
-- dump(entry)
if entry.dataType and entry.dataType == 'statistics' then
-- log('D', logTag, 'processCampaignAchievements called...')
-- dump(scenarioData)
local data = (not scenarioResult.failed and scenarioData.onEvent.onSucceed) or scenarioData.onEvent.onFail
end
-- dump(data)
-- -- log('I', logTag, 'onDeserialized called...')
-- -- dump(data)
-- if data.campaignActive then
-- local campaignToStart = loadCampaign(data.sourceFile)
-- -- dump(campaignToStart)
-- campaign = processCampaignStartInternal(campaignToStart)
campaign.state = data
--dump(campaign.state)
startExecution()
@/lua/ge/extensions/core/dynamicProps.lua
for i = 1, rayCount, 1 do
dump(i - iOffset)
dump(left)
dump(i - iOffset)
dump(left)
local actualPos = cameraPos + left * (i - iOffset)
local actualPos = cameraPos + left * (i - iOffset)
dump(actualPos)
dump(pos)
dump(actualPos)
dump(pos)
targetVec = actualPos - pos
debugDrawer:drawLine(actualPos, actualPos + targetVecLen * targetVec:normalized(), ColorF(0,0,1,1))
dump(targetVec)
dump(targetVecLen)
dump(targetVec)
dump(targetVecLen)
dump(castRayStatic(actualPos, targetVec:normalized(), targetVecLen))
dump(targetVecLen)
dump(castRayStatic(actualPos, targetVec:normalized(), targetVecLen))
dump("==============")
dump(castRayStatic(actualPos, targetVec:normalized(), targetVecLen))
dump("==============")
if castRayStatic(actualPos, targetVec:normalized(), targetVecLen) >= targetVecLen then return true end
end
dump("===============")
return false
locationInfo.linkedPropId = propId
dump("Spawning")
end
forest:getData():updateItem(forestItem:getKey(), locationInfo.originPos, forestItem:getData(), forestItem:getTransform(), forestItem:getScale(), forestItem:getUid())
dump("Despawning")
end
end
dump(tempCopy)
dynamicPropsObjs = deepcopy(tempCopy)
@/lua/vehicle/extensions/tech/OBDEmulator.lua
--dump(receiveBuffer)
end
--dump(messages)
receiveBuffer = b
receiveBuffer = b
--dump(receiveBuffer)
@/lua/common/extensions/networking/editorToolchain.lua
elseif data['cmd'] == 'subscribe' then
dump({'client wants to subscribe to data', getPeerName(connection), data})
if not subscriptions[connection] then
@/lua/ge/extensions/gameplay/markers/parkingMarker.lua
self.outlineId = outlineTmp:getId()
--dump("Outline Id" ,self.outlineId)
end
@/lua/ge/extensions/editor/flowgraph/nodelibrary.lua
elseif result.type == 'custom' then
dump(result)
result.info.customFunction(self, menuPos, result.info)
@/lua/ge/extensions/gameplay/race/race.lua
if isDebug then
dump(data.offTrackData.debugStuff)
end
extensions.hook("onRaceComplete", { race = self, time = self.time })
dump(self.states[id])
dumpz(self, 1)
@/lua/ge/extensions/gameplay/markerInteraction.lua
--for _, a in ipairs(activityData) do
-- dump(a.heading, (a.sorting and a.sorting.type) or "no type", a.sorting)
--end
showMarker = showMarker and (not cluster.visibleBySetting or markerVisibilityBySetting[cluster.visibleBySetting] or cluster.focus)
--dump(string.format("cluster %s, is nearby: %s, marker focus: %s, cluster focus: %s", cluster.id, nearbyIds[cluster.id], marker.focus, cluster.focus))
--dump(string.format("cluster %s, is showMarker: %s", cluster.id, showMarker))
--dump(string.format("cluster %s, is nearby: %s, marker focus: %s, cluster focus: %s", cluster.id, nearbyIds[cluster.id], marker.focus, cluster.focus))
--dump(string.format("cluster %s, is showMarker: %s", cluster.id, showMarker))
if showMarker then
@/lua/vehicle/extensions/tech/wheelForces.lua
end
--dump(v.data.beams)
for beamId, beam in pairs(v.data.beams) do
print("wheelforces.lua: " .. wd.name)
dump(data.suspensionBeamsNode1)
dump(data.suspensionBeamsNode2)
dump(data.suspensionBeamsNode1)
dump(data.suspensionBeamsNode2)
@/lua/common/extensions/ui/imguiWire.lua
end
--dump(results)
return results
@/lua/ge/extensions/util/worker.lua
N.renderVehiclePreview = function(w)
dump(w.vehicles)
test_renderVehiclePreview.renderVehiclePreview(w.vehicles)
@/lua/ge/extensions/campaign/dealer.lua
-- log('I', logTag, 'existItem called ... type(entryTable) = '..type(entryTable) ..' type(valueObj) = '..type(valueObj))
-- dump(entryTable)
-- dump(valueObj)
-- dump(entryTable)
-- dump(valueObj)
local found = false
-- dump(state.stock)
end
log('I', logTag, 'removeFromStock called... itemType '..tostring(itemType)..' '..type(valueObj))
-- dump(state.stock)
-- log('I', logTag, 'after removeFromStock')
-- dump(state.stock)
end
log('D', logTag, 'onDeserialized called...')
-- dump(data)
end
@/lua/vehicle/controller/driveModes.lua
local function applyDriveMode(mode)
--dump(mode)
for _, settingsKey in ipairs(mode.settingsOrder) do
--dump(modeData)
--dump(enabledModeKeys)
)
--dump(modeSorting)
--dump(driveModes)
--dump(enabledDriveModes)
--dump(driveModeOrder)
@/lua/vehicle/controller/etkGauges.lua
data.speed = wheelspeed
--dump(data)
@/lua/ge/extensions/flowgraph/nodes/career/careerVehicleSelect.lua
self.open = true
-- dump("opening dialogue!")
@/lua/ge/extensions/campaign/exploration.lua
-- log('I', logTag, 'Spawning Player in exploration : ')
-- dump(spawningData)
spawningPlayer = spawningData
minimap.worldCoord.y = -0.5 * minimap.worldCoord.h
--dump(minimap)
end
if locationData and locationData.info then
-- dump(locationData)
local locationInfo = locationData.info
if state.triggerCallback and type(state.triggerCallback) == 'function' then
-- dump(state.triggerCallback)
state.triggerCallback()
end
-- dump(info)
return info, missionLogOnly
data = deepcopy(M.state)
-- dump(data)
-- writeFile("campaign_exploration.txt", dumps(data))
-- log('D', logTag, 'onDeserialized called...')
-- dump(data)
M.state = deepcopy(data)
local processedScenario = scenario_quickRaceLoader.loadQuickrace(M.state.locationKey, scenarioFile, trackFile, vehicleFile)
--dump(processedScenario)
startSelectedScenario(processedScenario)
log('I', logTag, 'uiEventSelectVehicle called... Location: '..state.locationKey)
-- dump(vehicleData)
-- log('I', logTag, 'onCameraToggled called...')
-- dump(data)
local state = M.state
@/lua/ge/extensions/editor/dynamicDecals/loadSave.lua
if res.status.code ~= 0 then
dump(res)
notification.add("Load/Save", "Baking Issues", "Issues occured when baking decals.\nCheck the layer stack in order to identify the issues.", notification.levels.warning)
@/lua/ge/extensions/campaign/campaignsLoader.lua
--dump(campaign)
return campaign
local campaignInfofiles = getCampaignFilenames()
-- dump(campaignInfofiles)
local campaignList = {}
table.insert(campaignList, entry)
--dump(entry)
end
end
-- dump(campaignList)
return campaignList
local location = subsection.locations[locationKey]
-- dump(location.path)
return location.path ~= nil
end
--dump(fieldParts)
return fieldParts
--dump(locationData)
end
local processedCampaign = {meta = newCampaign, state = {}}
-- dump(processedCampaign)
-- dump(campaign)
return processedCampaign
local files = FS:findFiles('/saves/campaigns/', '*.json', 1, true, false)
--dump(files)
@/lua/ge/extensions/editor/missionEditor/genericTypeData.lua
self._vars = self.missionTypeEditors[self.mission.missionType]:getAllFieldNames()
--dump(self._vars)
self._sortedVars = {missing = {}, mismatch = {}, found = {}, other = {}}
@/lua/ge/extensions/core/audio.lua
local useHeadphones = TorqueScriptLua.getBoolVar('$pref::SFX::enableHeadphonesMode')
--dump("useHeadphones = "..tostring(useHeadphones))
@/lua/vehicle/extensions/tech/tyreBarrier.lua
file:close()
dump("Test data written to file: " .. outputFilename)
end
controller.unloadControllerExternal('advancedIMU' .. sensorId)
dump("imu controller removed")
controller.unloadControllerExternal('tyreBarrier' .. sensorId)
controller.unloadControllerExternal('tyreBarrier' .. sensorId)
dump("tyreBarrier controller removed")
end
@/lua/ge/extensions/flowgraph/nodes/ui/contextTranslation.lua
dump("string: "..self.string)
-- update state
@/lua/ge/extensions/editor/rallyEditor/pacenotes/structuredForm.lua
local function dumpPacenote(pacenote)
dump(pacenote.structured.fields)
end
@/lua/vehicle/wheels.lua
--dump(M.wheels)
--dump(M.rotators)
--dump(M.wheels)
--dump(M.rotators)
end
@/lua/ge/extensions/editor/gen/decal.lua
local akey = {key}
U.dump(key, '?? for_val:'..v..':'..tostring(mm[akey[1] ]))
end
if g == nil or g[1] == nil or g[2] == nil or aref[g[1]] == nil then
-- U.dump(g, '!! ERR_nil:')
-- return
if aref[g[1]] ~= nil and aref[g[1]][g[2]] ~= nil then
-- U.dump(aref[g[1]][g[2]], '?? for_reff:'..tostring(g[1])..':'..tostring(g[2]))
-- if true then return end
if rsrc == 68 and rtgt == 192 then
U.dump(across[rsrc][n], '??____ chd2:'..rsrc..':'..n)
end
for ni,al in pairs(across[rsrc]) do
-- U.dump(al, '?? checking:'..ni)
for il,l in pairs(al) do
for il,l in pairs(al) do
-- U.dump(l, '?? link_check:')
if l[1] == rtgt then
if d < l[3] then
-- U.dump(al, '?? to_remove:'..rtgt..':'..il)
table.remove(al, il)
table.remove(al, il)
-- U.dump(across[rsrc], '?? removed:'..#al..':'..ni)
if true then --and rsrc == 68 then
if true then --and rsrc == 68 then
-- U.dump('?? removing:'..ni)
if #al == 0 then
-- if rtgt == 232 and rsrc == 68 then
-- U.dump(across[rtgt], '??____ appended:'..rsrc..':'..n)
-- U.dump(across[rsrc][n], '??____ appended:'..rsrc..':'..n)
-- U.dump(across[rtgt], '??____ appended:'..rsrc..':'..n)
-- U.dump(across[rsrc][n], '??____ appended:'..rsrc..':'..n)
-- end
-- if i == 526 and j == 355 then
-- U.dump(across[rsrc][n], '?? S-T:'..rsrc..':'..rtgt)
-- end
lo('<< forCross:'..tableSize(across)..':'..nc) --..':'..tostring(out.avedit[1])..':'..tostring(out.avedit[2]))
-- U.dump(across)
return across
-- if roadID == dbg then
-- U.dump(anode, '?? for_NODES:'..dbg)
-- end
-- local i,j = math.floor((n.y + L)/grid) + 1,math.floor((n.x + L)/grid) + 1
-- U.dump(aref[526][355], '???*************** aref:'..tostring(aref[526])..':'..tostring(n)..':'..i..':'..j)
-- lo('?? pos:'..tostring(adec[302].list[1])..':'..tostring(adec[49].list[1])..':'..tostring(adec[362].list[3])..':'..tostring(adec[49].list[1]))
lo('?? for_across:'..tableSize(out.across)..':'..#adec)
-- U.dump(across)
-- D.toMark(adec[2].list,'cyan',nil,0.1,1)
-- lo('?? for_stamp:'..ind..':'..k..':'..stamp)
-- U.dump(c, '?? for_a:'..ind)
if not djunc[stamp] then
djunc[stamp] = 1
-- U.dump(c, '?? for_end:'..ind..':'..k) --..':'..c[1][1])
ajunc[#ajunc+1] = {p=adec[ind].list[k], list=abr}
D.toMark({ajunc[#ajunc].p},'mag',nil,0.2,1)
U.dump(c, '?? for_CROSS8:'..ind..':'..k)
for t,b in pairs(ajunc[#ajunc].list) do
-- if #ajunc == 24 then
-- U.dump(ajunc[#ajunc].list, '?? for_JUNC:')
-- end
-- lo('?? forc:'..tostring(ind)..':'..tostring(c[1]))
-- U.dump(c, '?? forc1:'..ind)
end
lo('?? ajunc:'..#ajunc) --..':'..tostring(ajunc[1].p))
-- U.dump(ajunc, '?? for_ajunc:')
-- icheck = 32 --157
end
-- U.dump(adec[10].list, '?? list:')
lo('<< decalsLoad:'..(nrd-1)..':'..#across..' adec:'..#adec..'/'..tableSize(editor.getAllRoads())..' aref:'..#aref..':'..tableSize(aref)) --..':'..tostring(adec[49].list[1]))
local step = L/nn
-- U.dump(list, '??+++++++++ rd_check:'..roadID..':'..ne..' L:'..L..':'..nn..':'..step)
local newlist = {list[1].pos}
-- out.avedit = newlist
-- U.dump(newlist, '?? nodes:')
if false and rd:getOrCreatePersistentID() == 'f3821e74-24c6-4630-b32b-9d28e0a5cd4b' then
local step = L/nn
U.dump(list, '??+++++++++ rd_check:'..roadID..':'..ne..' L:'..L..':'..nn..':'..step)
local newlist = {list[1].pos}
out.avedit = newlist
U.dump(newlist, '?? nodes:')
D.nodesUpdate({body=rd, w=list[1].width}, newlist)
lo('?? if_TB: size:'..tostring(tersize)..':'..forZ(vec3(-tersize.x/2+25,0.2))..' wb:'..tostring(tb:getWorldBox())..':'..tostring(tfr))
-- U.dump(extents, '?? for_TB:'..tostring(tb)..' sz:'..tostring(tb:getSquareSize()))
else
for ij,d in pairs(mask) do
-- U.dump(ij, '?? undo_ij:'..tostring(grid2p(ij))..':'..tostring(d[1]))
tb:setHeightWs(grid2p(d[4]), d[1]) -- 107) -- d[1])
out.avedit = {}
if dbg then U.dump(bcross, '?? road2ter:'..ind..':'..adec[ind].id..':'..tableSize(bcross)..' w:'..tostring(rd.aw and rd.aw[1] or rd.w)) end
--- go over cross points on the branch
-- lo('?? for_I:'..i)
-- U.dump(ref, '?? for_end:'..i)
-- ref.dir = i==1 and 1 or -1
for j,b in pairs(ref) do
-- U.dump(b, '?? for_B:'..tostring(j))
-- lo('?? for_B2:'..tostring(isnan(b))..':'..tostring(j)..':'..tostring(b))
-- lo('?? for_B2:'..tostring(isnan(b))..':'..tostring(j)..':'..tostring(b))
-- U.dump(ep, '?? for_ep:')
abranch[#abranch+1] = {ird=b[1], inode=b[2]}
end
-- U.dump(ref, '?? for_jrad:'..i..':'..jrad)
c = c/#abranch
end
-- U.dump(crossset, '?? crossset:')
end
end
-- U.dump(abranch, '?? for_end_br:'..i)
-- U.dump(n2e)
-- U.dump(abranch, '?? for_end_br:'..i)
-- U.dump(n2e)
--- get branches sides crossing
end)
-- U.dump(aang, '?? for_AANG:'..i)
pinext = 0
for k,d in pairs(aang) do
if dbg then U.dump(d, '?? for_ang:'..k) end
if d.ang == 0 then
if k < #aang and math.abs(aang[k+1].ang)
end
-- U.dump(aang, '?? aang:')
end
end
if dbg then U.dump(rd.djrad, '?? for_len:'..jrad..'/'..rd.L) end
if 2*(jrad+jmargin)>rd.L then
end)
-- U.dump(rd.apin, '?? apin:'..rd.L..':'..jrad)
-- U.dump(bcross, '?? road2ter:'..ind..':'..adec[ind].id)
-- U.dump(rd.across, '?? for_rdcross:'..#rd.across..':'..core_terrain.getTerrainHeight(rd.across[1])..':'..core_terrain.getTerrainHeight(rd.across[3]))
-- U.dump(bcross, '?? road2ter:'..ind..':'..adec[ind].id)
-- U.dump(rd.across, '?? for_rdcross:'..#rd.across..':'..core_terrain.getTerrainHeight(rd.across[1])..':'..core_terrain.getTerrainHeight(rd.across[3]))
for i=2,#rd.across do
-- evaluate slope
-- U.dump(rd.across[i], '?? forAC:')
-- lo('?? for_DH:'..(core_terrain.getTerrainHeight(rd.across[i][2])-core_terrain.getTerrainHeight(rd.across[i-1][2])))
end
-- U.dump(out.yel, '?? pre_height:'..#rd.apin..':'..#out.yel)
else
-- dbg = true
U.dump(rd.frtoside, '??+++++++++++++++++++++++++++++++ for_FRTO:'..rd.L..':'..forZ(rd.frtoside[1].p))
-- U.dump(rd.apin, '?? ex_APIN:')
U.dump(rd.frtoside, '??+++++++++++++++++++++++++++++++ for_FRTO:'..rd.L..':'..forZ(rd.frtoside[1].p))
-- U.dump(rd.apin, '?? ex_APIN:')
-- local cs = D.borderCross(rd.body, adec[rd.frto[1]].body, 'left', 'left', 0, 0)
rd.apin[#rd.apin+1] = {d=rd.frtoside[1].d/2, h=forZ(p)}
-- U.dump(rd.apin, '?? for_PIN:')
-- toMark(rd.apin, 'blue', nil, 0.1, 0.4)
rd.apin[#rd.apin+1] = p
-- U.dump(rd.apin, '?? for_PIN:')
-- toMark(rd.apin, 'blue', nil, 0.1, 0.4)
end
-- if dbg then U.dump(rd.apin, '?? APIN:'..rd.ind) end
if dbg then U.dump(rd.apin, '??^^^^^^^^^^^^^^^^^^ for_APIN::'..itofill) end
-- if dbg then U.dump(rd.apin, '?? APIN:'..rd.ind) end
if dbg then U.dump(rd.apin, '??^^^^^^^^^^^^^^^^^^ for_APIN::'..itofill) end
if dbg then
U.dump(rd.apin, '?? post_pin_FILL:'..#rd.apin..':'..l..':'..nstep..':'..i)
toMark(rd.apin, 'green', function(d) return D.onSide(rd, 'middle', d.d) end, 0.15, 0.2)
if dbg then
U.dump(rd.apin, '?? pre_slope:')
toMark(rd.apin, 'green', function(d)
end, 0.15, 0.2, true)
-- U.dump(out['green'], '?? for_G:')
end
end
-- U.dump(out.blue, '?? for_blue:')
]]
if dbg then U.dump(rd.apin, '?? aPIN_fix:') end
end
-- U.dump(ap, '?? pre_pS:')
apar = U.paraSpline(ap)
apar = U.paraSpline(ap)
-- U.dump(apar, '??********* apar0:'..#ap)
-- U.dump(apar, '??********* apar:'..#ap)
-- D.forHSpline()
end
-- U.dump(ap, '?? for_AP:')
-- U.dump(acp, '?? for_ACP:'..rd.L)
-- U.dump(ap, '?? for_AP:')
-- U.dump(acp, '?? for_ACP:'..rd.L)
for i=2,nsstep-1 do
end
-- U.dump(ap, '??^^^^^^^^^^^^^^^^^^ for_AP:'..nsstep..':'..#acp)
for i=2,#acp-1 do
cpar[#cpar+1] = cpar[#cpar]
-- U.dump(acp, '??**************** ACP:'..#acp)
----------------------------
end
-- U.dump(ae, '?? AE:'..#ae)
-- U.dump(legend['blue'], '?? for_blue:'..tostring(legend['blue'][1].alpha))
--[[
end
U.dump(out.ared, '?? for_ae:'..#ae)
]]
]]
-- U.dump(rd.e2d, '?? e2d:')
-- local amark = {}
if i == 3091 and j == 2614 then
-- U.dump(ae,'?? for_IJ:'..i..':'..j..':'..#ae..':'..#am3..':'..tostring(D.epos(rd.body,1)))
-- toMark(am3, 'mag', nil, 0.05, 0.3)
out.white = {p + vec3(0,0,forZ(p)), pp + vec3(0,0,forZ(pp))}
U.dump(out.ared, '?? pp:'..tostring(p)..':'..tostring(pp))
end
-- for key,d in pairs(mask) do
-- U.dump(d, '?? for_mask:'..tostring(key))
-- end
-- end
-- U.dump(mask, '?? for_MASK:')
-- toMark(am1, 'white', nil, 0.05, 0.3) --, true)
out.inconform = true
U.dump(askip, '?? to_skip:')
for _,rd in pairs(list) do
--[[
U.dump(rd.apin, '?? pin_pre_slope:'..#rd.apin)
toMark(rd.apin, 'white', function(d)
-- apar[#apar+1] = apar[#apar]
-- U.dump(apar, '?? apar:'..i)
end
end
-- U.dump(adec[1], '?? ndec:'..#adec) --..':'..tdec[1])
-- to squares
-- lo('<< decalsLoad:'..tostring(#aref)..':'..tostring(#aref[100])..':'..nn)
-- U.dump(aref[365][455][1], '?? forr:')
-- for i = 1,math.ceil(4096*2/step) do
]]
-- U.dump(desc, '>> decalUp:')
if not desc.list then return end
if dbg then
U.dump(aind, '?? toPath:'..rd.ne)
end
if not awidth then awidth = {} end
-- U.dump(awidth, '?? nodesUpdate:')
if rd.on == false then
end
-- U.dump(apos, '?? nodesUpdate:'..#anode..':'..#apos)
-- lo('?? e_UPD:'..junc.wexit) -- tostring(junc.aexit[i].body)..':'..#anode)
-- local edesc = exitUp(junc.list[1].body, junc.list[2].body, junc.wexit, junc.rexit)
-- U.dump(junc.aexit, '?? for_el:'..junc.rexit)
-- render exit
-- local rd = bdesc.body
-- U.dump(bdesc, '>> toJunc:'..tostring(rd)..':'..bdesc.io)
local anode = editor.getNodes(bdesc.body)
if b.dirty then
-- U.dump(b.aex, '?? jup:'..i)
toJunc(jdesc, i)
local margin = rd.w/(rd.lane[1] + rd.lane[2])*ilane -- - rd.w/2
-- U.dump(rd.lane, '?? line4laneD:'..rd.w..':'..ilane..':'..margin)
-- lo('?? line4laneD:'..rd.L..':'..dr)
if toupdate then
-- U.dump(b.listrad, '?? LISTRAD:'..i)
else
-- out.avedit = b.list -- {b.list[2]}
-- U.dump(b.list, '?? b_LIST:'..i..':'..#b.list)
-- out.avedit = b.listrad
-- middle line
-- U.dump(b.aline[il].list, '?? pre_ml:')
for i = #b.list,#b.listrad do
local ldesc = line4lane(b, b.lane[1], jdesc.round.w/2)
U.dump(ldesc.list, '?? for_middle:'..i..':'..il)
-- out.avedit = b.listrad
-- out.ared = {ajunc[cjunc].p}-- ldesc.list
-- U.dump(b.list)
-- U.dump(ldesc.list, '??++++++++++++ for_ml:'..#b.list)
-- U.dump(b.list)
-- U.dump(ldesc.list, '??++++++++++++ for_ml:'..#b.list)
-- out.avedit = {b.list[#b.list]}
local e = adec[idec]
-- U.dump(e, '?? ex_upd:'.._)
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(e, '?? ex_upd:'.._)
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(b.aline, '?? for_line:')
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(b.aline, '?? for_line:')
-- get distance on circle
e.mat = 'road1_concrete'
-- U.dump(e, '?? for_e:')
forExit(adec[e.frto[1]], jdesc.round, e)
-- lo('?? al:'..tostring(aline))
-- U.dump(aline, '?? line2:'..#adec[b.aexo[1]].aline)
-- out.avedit = aline[1].list
if toupdate then
-- U.dump(b.listrad, '?? LISTRAD:'..i)
else
-- out.avedit = apos
-- U.dump(apos, '?? apos:')
-- lo('?? for_apos:'..#apos)
-- out.avedit = b.list -- {b.list[2]}
-- U.dump(b.list, '?? b_LIST:'..i..':'..#b.list)
-- out.avedit = b.listrad
--- compete nodes
-- U.dump(b.aline[il].list, '?? pre_ml:')
for i = 1,#b.listrad-#b.list do
local ldesc = U._MODE == 'conf' and line4laneD(b, b.lane[1], jdesc.round.w/2) or line4lane(b, b.lane[1], jdesc.round.w/2)
-- U.dump(b.lane, '?? for_middle:'..i..':'..il..':'..tostring(#b.aline))
-- toMark(ldesc.list, 'yel')
-- out.ared = {ajunc[cjunc].p}-- ldesc.list
-- U.dump(b.list)
-- U.dump(ldesc.list, '??++++++++++++ for_ml:'..#b.list)
-- U.dump(b.list)
-- U.dump(ldesc.list, '??++++++++++++ for_ml:'..#b.list)
-- out.avedit = {b.list[#b.list]}
local e = adec[idec] or {}
-- U.dump(e, '?? ex_upd:'.._)
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(e, '?? ex_upd:'.._)
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(b.aline, '?? for_line:')
-- U.dump(e, '?? for_exito:'..i..':'..e.frto[1]..'>'..e.frto[2]..':'..jdesc.round.in d..':'..e.db..':'..U.vang())
-- U.dump(b.aline, '?? for_line:')
-- get distance on circle
e.mat = 'road1_concrete'
-- U.dump(e, '?? for_e:')
forExit(b, jdesc.round, e, true)
-- forExit(jdesc.round, adec[e.frto[1]], eleft, true, i == 3)
-- U.dump(eleft.list, '?? for_LEFT:'..i)
-- toMark(b.list, 'mag')
-- lo('?? al:'..tostring(aline))
-- U.dump(aline, '?? line2:'..#adec[b.aexo[1]].aline)
-- out.avedit = aline[1].list
local function vert2junc(abr)
-- U.dump(abr, '>> vert2junc:')
out.acyan = {abr[1].list[1]}
end
-- U.dump(bout.djrad, '?? for_rad:'..i)
local bin = U.mod(i+1,abr)
for i,b in pairs(abr) do
-- U.dump(b.djrad, '??++++++++++++++ for_rad:'..i)
-- lo('?? for_mid:'..tostring(b.ne)..':'..b.io..':'..b.w)
line.list = pin2sideD(b, b.io==1 and 'right' or 'left', dw, b.L-dw, margin, 6)
-- U.dump(line.list, '?? ll:'..i)
-- toMark(list, 'red', nil, 0.1)
-- U.dump(line,'?? for_line:'..i)
b.aline[#b.aline+1] = line
-- amatch[2] = nil
-- U.dump(amatch)
local function ifCross(k,m)
-- if U.line2seg(pfr,pto,pfr2,pto2) and U.line2seg(pfr2,pto2,pfr,pto) then
-- U.dump(amatch)
-- return true
end
-- U.dump(pfr)
local jifr,jito = adec[amatch[k].ind].ij,adec[amatch[m].ind].ij
end
-- U.dump(atry)
end
amatch[k].skip = true
U.dump(atry,'?? no_MATCH:'..k) --..':'..tostring(out.aplot))
-- U.dump(amatch)
U.dump(atry,'?? no_MATCH:'..k) --..':'..tostring(out.aplot))
-- U.dump(amatch)
-- return
n = n + 1
-- U.dump(atry, '?? atry:'..n..':'..tostring(out.aplot)..':'..tostring(match))
-- U.dump(amatch)
-- U.dump(atry, '?? atry:'..n..':'..tostring(out.aplot)..':'..tostring(match))
-- U.dump(amatch)
end
local rda,rdb = adec[d.ind],adec[amatch[d.to].ind]
-- U.dump(rdb.list, '?? rda:')
aplot[#aplot+1] = {
if not indrag then
U.dump(atry, '?? atry:'..n..':'..tostring(out.aplot)..':'..tostring(match))
U.dump(amatch)
U.dump(atry, '?? atry:'..n..':'..tostring(out.aplot)..':'..tostring(match))
U.dump(amatch)
end
end
-- U.dump(atry, '?? to_try:'..n)
-- U.dump(tomatch, '?? tM:')
-- U.dump(atry, '?? to_try:'..n)
-- U.dump(tomatch, '?? tM:')
break
end
U.dump(atry, '?? to_try:'..n)
end
-- U.dump(aplot[#aplot], '?? for_br:'..i..':'..imi[1]..':'..imi[2])
else
end
U.dump(atry, '?? forPlot_ATRY:')
for k,t in pairs(atry) do
end
U.dump(aw, '?? lastITER:'..#list..':'..#desc.list)
]]
local jdesc = ajunc[ind]
-- U.dump(ajunc, '>> junctionDown:'..tostring(ind)..':'..#ajunc)
for i,b in pairs(jdesc.list) do
if adec[b.aexi[1]] and adec[b.aexi[1]].aline then
-- U.dump(adec[b.aexi[1]].aline, '?? for_ae_line:'..i)
for il,d in pairs(adec[b.aexi[1]].aline) do
end
-- U.dump(amatch, '?? amatch:')
end
for _,idec in pairs(b.aexo) do
-- U.dump(e, '?? ex_upd:'.._)
local e = adec[idec]
nodesUpdate(e)
-- U.dump(b.aline, '?? for_line:')
-- lines right
end
-- U.dump(e, '?? ex_upd:'.._)
-- nodesUpdate(sideLine(e, 'left', bout, 'left', bin, 'right', b.aline[4+1]))
if not cpick then return end
-- U.dump(adec, '>> ter2road:'..tostring(#adec or #adec)..':'..tostring(cpick)..':'..#editor.getAllRoads())
--
-- U.dump(across[cdec], '?? ter2road: cdec='..cdec..' nodes:'..tostring(#adec[cdec]))
-- U.dump(across[cdec], '?? ter2road: cdec='..cdec..' nodes:'..tostring(#adec[cdec]))
-- U.dump(across[cdec], '?? ter2road: cdec='..cdec..' nodes:'..tostring(#adec[cdec]))
-- U.dump(across[cdec], '?? ter2road: cdec='..cdec..' nodes:'..tostring(#adec[cdec]))
U.dump(out.avedit)
-- U.dump(across[cdec], '?? ter2road: cdec='..cdec..' nodes:'..tostring(#adec[cdec]))
U.dump(out.avedit)
local rcross = 5*croad:getNodeWidth(0)/3.5 -- radius of pinned around crossroad
local rcross = 5*croad:getNodeWidth(0)/3.5 -- radius of pinned around crossroad
U.dump(acp, '?? acp:'..anode[1].width..':'..tostring(anode[1].pos)..' rcross:'..rcross)
local dpin = 20 -- distance between pins
-- U.dump(andist, '??____ andist:')
-- U.dump(aedist, '?? aedist:')
-- U.dump(andist, '??____ andist:')
-- U.dump(aedist, '?? aedist:')
-- U.dump(acp, '?? acp:')
-- U.dump(aedist, '?? aedist:')
-- U.dump(acp, '?? acp:')
-- distances of edges and nodes from start
end
-- U.dump(aepin, '?? aepin:'..nsec)
if i < 20 then
-- U.dump(aeinfo[i], '?? aedist:'..i)
end
end
-- U.dump(aepin, '?? AEPIN:'..croad:getEdgeCount())
U.dump(ain, '?? AIN:')
-- U.dump(aepin, '?? AEPIN:'..croad:getEdgeCount())
U.dump(ain, '?? AIN:')
aspline = U.paraSpline(ain)
aspline[#aspline + 1] = aspline[#aspline]
U.dump(aspline, '?? splined:'..#aspline)
--[[
})
U.dump(acoef, '?? splined:'..i)
end
local pin1,pin2 = aepin[aeinfo[imi].ipin][1],aepin[aeinfo[imi].ipin+1][1]
-- U.dump(aeinfo[imi], '?? dt: ie:'..imi..':'..ap[y][x][1]..':'..tostring(t)..':'..tostring(aeinfo[imi].pos)..':'..tostring(p1)..':'..tostring(p2)..' pin1:'..pin1..' pin2:'..pin2..' d1:'..aeinfo[pin1].d..' d2:'..aeinfo[pin2].d)
local fromOrigin = aeinfo[imi].d + (aeinfo[imi+1].d - aeinfo[imi].d)*p1
lo('<< ter2road:'..#out.avedit..':'..#shmap..':'..aeinfo[#aeinfo].d) --....croad:getField("Material", "")..':'..tostring(croad:getPosition()))
-- U.dump(ap, '?? asq:'..tostring(asq[1])..':'..tableSize(ap))
end
-- out.apoint = {}
-- U.dump(aedist, '?? aedist:'..ifr..':'..ito)
end
if imi == nil then
-- U.dump(ae,'?? for_IMI:'..i..':'..tostring(imi)..':'..#ae..':'..tostring(t))
-- out.apoint[#out.apoint+1] = t
]]
-- U.dump(andist, '?? ndist:')
-- lo('?? EN:'..tostring(croad:getMiddleEdgePosition(nsec-1))..':'..tostring(anode[#anode].pos))
-- U.dump(anode[1], '?? for_adec:'..tostring(adec[1][1]))
--[[
end
-- U.dump(list, '<< node2edge:'..#list)
return list
cdec = i
-- U.dump(us, '?? us:')
-- U.dump(pp, '?? neigh:')
-- U.dump(us, '?? us:')
-- U.dump(pp, '?? neigh:')
--[[
table.sort(star, comp)
U.dump(star, '?? star_post:')
for _,b in pairs(star) do
astem[#astem + 1] = {cdec, ndi}
-- U.dump(across[cdec][ndi], '?? sideUp.stem:') --across[cdec], '?? acr:'..i)
local star = U.forStar(astem, adec)
local star = U.forStar(astem, adec)
-- U.dump(star, '?? star: rdi:'..cdec..' node:'..ndi)
-- get neighbours
-- U.dump(pp, '?? NB: us='..cpick..' end='..ndi) --..#adec[pp[2].rdi].list)
-- U.dump(bright, '?? for_RIGTH_branch:')
-- U.dump(pp, '?? NB: us='..cpick..' end='..ndi) --..#adec[pp[2].rdi].list)
-- U.dump(bright, '?? for_RIGTH_branch:')
local usfr = ndi == 1 and 0 or (nsec - 1) --
local function forSide(br, flip)
-- U.dump(br, '>> forSide:'..tostring(flip)..':'..us.rdi..'>'..br.rdi)
local rdthem = adec[br.rdi].body
-- local n2e = node2edge(croad)
-- U.dump(n2e, '?? n2e:'..ie)
local ipre
local function forStar(astem, ard)
U.dump(astem, '>> forStar:')
if not ard then ard = adec end
-- aang[#aang + 1] = {i, math.atan2(v.y, v.x) % (2*math.pi)}
U.dump(aflag, '<< forStar:')
return aflag
elseif key == 'b_road' then
-- U.dump(out.inplot, '?? b_road:'..#out.inplot)
decalUp({
b.lane = {lane[1],lane[2]}
-- U.dump(b.lane,'??__________________________ for_rd_w:'..tostring(w)..':'..nln..':'..math.random(1,nln-1)..':'..tostring(ajunc[cjunc].p)..':'..tostring(b.list[1]))
b.aexi={}
end
U.dump(abr[i].djrad, '?? djrad:'..#abr[i].list)
local jr = abr[i].io == 1 and abr[i].djrad[1] or abr[i].djrad[#abr[i].list] or abr[i].w/2
ajunc[cjunc].r = rma*default.radcoeff
-- U.dump(dang, '?? dang:')
-- road2ter({abr[1].ind},true)
-- print('?? tb_UPDTED2:')
U.dump(b.djrad, '??______ for_r:'..b.ind..':'..b.jrad)
local ni = b.list[1]:distance(junc.p) < U.small_dist and 1 or #b.list
idec=rdnext.ind}
U.dump(car.target.exit, '?? targ_update_ex:')
-- car.target.rd = ajunc[rd.ij[1]].list[imi]
if not car.target then return end
-- U.dump(car.target, '>> toExit:')
local rd = car.target.rd
lo('?? toExit:'..tostring(car.target)..':'..tostring(#rd.aexo))
-- U.dump(rd, '>> toExit:')
local dmi,pmi,imi = math.huge
end
U.dump(car.target.exit,'<< toExit:'..tostring(dmi)..':'..#rd.aexo)
return false
return false
-- U.dump(rd.aexo[1],'?? aex:'..#rd.aexo)
end
if ijmi then
U.dump(ijmi, '?? cand_found:'..tostring(dmi)..':'..adec[ijmi[1]].id..':'..tostring(car.pos))
local icheck = 43
-- out.avedit = {adec[ijmi[1]].list[ijmi[2]], target}
U.dump(ijmi, '?? found:'..tostring(target)..':'..adec[ijmi[1]].id..':'..dir)
car.target = {
forBranch(rd)
-- U.dump(car.target, '')
target = car.target
-- out.agreen = {car.target.rd.list[#car.target.rd.list]}
-- U.dump(rd.frto,'?? E2B:'..tostring(rd.j)..':'..tostring(car.target.rd)..' e:'..tostring(car.target.ie))
-- if true then return end
end
-- U.dump('?? no_TARGET:')
-- return
-- lo('?? post_GEN:'..#amatch)
-- U.dump(amatch, '?? AMATCH:')
-- if true then return end
if ijmi then
U.dump(ijmi, '?? cand_found:'..tostring(dmi)..':'..adec[ijmi[1]].id..':'..tostring(car.pos))
local icheck = 43
-- out.avedit = {adec[ijmi[1]].list[ijmi[2]], target}
U.dump(ijmi, '?? found:'..tostring(target)..':'..adec[ijmi[1]].id..':'..dir)
return {
idec=rdnext.ind}
-- U.dump(car.target, '?? targ_update:')
-- car.target.rd = ajunc[rd.ij[1] ].list[imi]
ps = U.proj2D(ps)
-- U.dump(e2d, '?? for_e2:'..ifr..':'..tostring(ps)..':'..tostring(epos(rd.body,ifr)))
local dsplit = e2d[ifr] + ps:distance(epos(rd.body,ifr))
end
-- U.dump(ap, '?? for_AP:'..#ap..':'..tostring(ap[3]))
if dbg then toMark(ap, 'white', nil, 0.08, 0.8) end
-- local nstep = math.floor(pfr:distance(pto)/pinstep+0.5)
-- U.dump(pth, '>> decalPlot:'..#pth..':'..pfr:distance(pto))
end
-- U.dump(list, '?? LIST:'..tostring(done)..':'..n)
if dbg then lo('?? next_L: L:'..#list..' n:'..n..':'..tostring(done)) end
-- lo('?? for_i:'..i..':'..tostring(list[i-1]))
-- U.dump(list[i-1], '?? l-1:'..i)
acrv[#acrv+1] = U.curv(list[i-1].e[1],list[i].e[1],list[i+1].e[1])
end
if dbg then U.dump(acrv, '?? for_curv:') end
out.aseg = {}
end
-- U.dump(list, '?? for_LIST:')
-- if true then return end
local target = car.target or forTarget()
-- U.dump(out.avedit,'?? if_target:'..tostring(target))
if target then
m.to = nil
U.dump(amatch, '?? for_am:')
break
if edesc then
U.dump(edesc.frtoside, '?? ex_FRTO:')
D.road2ter({edesc.ind})
side=side}
U.dump(out.sidepick, '?? for_sp:')
end
if edesc then
U.dump(edesc.frtoside, '?? ex_FRTO:')
D.road2ter({edesc.ind})
side=side}
U.dump(out.sidepick, '?? for_sp:')
end
if #out.sidepick.list == 2 then
U.dump(out.sidepick, '?? for_SP:') --..tableSize(out.sidepick.split)..':'..jmi..':'..adec[jmi].id)
-- lo('?? SP_PRE:'..#across)
-- lo('?? SP_POST:'..#across)
-- U.dump(across[#across], '?? ADDED:'..adec[#adec].ind..':'..adec[#adec].id)
for _,d in pairs(adec) do
if d.id == id then
-- U.dump(across[d.ind], '?? cross:'..d.id..':'..d.ind)
local cross = {}
end
-- U.dump(across, '?? ACR:')
return 1
end
U.dump(out.ared, '?? ared:')
lo('??**************** D.onUp_DONE:'..tostring(cdescmo)..':'..#apick)
local ind = inAdec(cpick)
U.dump(across[ind], '?? picked:'..tostring(ind)..':'..tostring(cpick)..':'..tostring(croad)..':'..tostring(croad and croad:getOrCreatePersistentID() or nil))
-- croad:setField("material", 0, "road1_concrete")
-- out.avedit[#out.avedit+1] = car.target.p
-- U.dump(car.target, '?? if_EXIT:')
-- toTarget(0,-1)
end
-- U.dump(car.target, '?? for_COMMAND:'..incommand[1]..':'..tostring(inexit))
ccommand = incommand[1]
elseif incommand[1] == 'left' and car.target.rd then
-- U.dump(adec[car.target.rd.ind].lane, '?? if_LANE:'..tostring(car.target.lane)..':'..tostring(car.target.side))
local nlane = car.target.side=='right' and adec[car.target.rd.ind].lane[2] or adec[car.target.rd.ind].lane[1]
for _,d in pairs(out.aplot) do
-- U.dump(d, '?? merging:'.._)
branchMerge(adec[amatch[d.fr].ind], adec[amatch[d.to].ind])
end
U.dump(out.ared, '?? ared:')
lo('??**************** D.onUp_DONE:'..tostring(cdescmo)..':'..#apick)
local ind = inAdec(cpick)
U.dump(across[ind], '?? picked:'..tostring(ind)..':'..tostring(cpick)..':'..tostring(croad)..':'..tostring(croad and croad:getOrCreatePersistentID() or nil))
-- croad:setField("material", 0, "road1_concrete")
astem[#astem + 1] = {i, ndi}
U.dump(across[cdec][ndi], '?? stem:') --across[cdec], '?? acr:'..i)
local star,us = U.forStar(astem, adec)
local star,us = U.forStar(astem, adec)
-- U.dump(star, '?? star_got:'..i)
for _,f in pairs(star) do
width = w, drivability = 1, index = 0 }
-- U.dump(across[fmi.rdi], '?? POST_cross:')
--- from us
U.dump(across[cdec][ndi], '?? to_checkll:')
local abranch,irem = {}
end
-- U.dump(across[cdec][ndi], '?? POST_rem:')
-- U.dump(abranch, '?? to_clean:')
-- U.dump(across[cdec][ndi], '?? POST_rem:')
-- U.dump(abranch, '?? to_clean:')
--- from theirs
for _,rdi in pairs(abranch) do
-- U.dump(across[rdi], '?? to_up:'..rdi)
for n,alnk in pairs(across[rdi]) do
if lnk[1] == cdec then
-- U.dump(alnk, '?? TO_update:'..cdec)
lnk[2] = lnk[2] + 1
end
-- U.dump(across[rdi], '?? post_up:'..rdi)
end
for i,e in pairs(out.aseg) do
-- U.dump(e, '?? for_eg:'..#out.aseg)
-- Render.path(e, color(255,255,0,155), 1)
@/lua/ge/extensions/editor/aiTests.lua
if im.Button("Dump Route") then
dump(route)
end
@/lua/ge/extensions/flowgraph/nodes/debug/display.lua
if im.Button("Dump##"..self.id) then
dump(self._lastVal)
end
@/lua/ge/map.lua
if not matchedL2[i] then
dump(nodeList2[i])
else
if not matchedL1[i] then
dump(nodeList1[i])
end
if not matchedL2[i] then
dump(edgeList2[i])
else
if not matchedL1[i] then
dump(edgeList1[i])
end
if linksOk and (numOfLinks % 2 == 0) then
dump('---> Links Are Ok. -> ', numOfLinks * 0.5, numOfNodes)
else
-- connect n1 to nodeName
--if map.nodes[n1].links[nodeName] then dump('1 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!', n1, nodeName, n2) end -- TODO: remove debug
map.nodes[n1].links[nodeName] = {
graphDataHistory['load'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['load'][1])
dump(graphDataHistory['load'][2])
dump(graphDataHistory['load'][1])
dump(graphDataHistory['load'][2])
print('')
graphDataHistory['Merge_Nodes_0'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['Merge_Nodes_0'][1])
dump(graphDataHistory['Merge_Nodes_0'][2])
dump(graphDataHistory['Merge_Nodes_0'][1])
dump(graphDataHistory['Merge_Nodes_0'][2])
print('')
graphDataHistory['optimizeNodes_0'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['optimizeNodes_0'][1])
dump(graphDataHistory['optimizeNodes_0'][2])
dump(graphDataHistory['optimizeNodes_0'][1])
dump(graphDataHistory['optimizeNodes_0'][2])
print('')
graphDataHistory['Merge_Nodes_1'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['Merge_Nodes_1'][1])
dump(graphDataHistory['Merge_Nodes_1'][2])
dump(graphDataHistory['Merge_Nodes_1'][1])
dump(graphDataHistory['Merge_Nodes_1'][2])
print('')
graphDataHistory['T_Junctions'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['T_Junctions'][1])
dump(graphDataHistory['T_Junctions'][2])
dump(graphDataHistory['T_Junctions'][1])
dump(graphDataHistory['T_Junctions'][2])
print('')
graphDataHistory['X_Junctions'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['X_Junctions'][1])
dump(graphDataHistory['X_Junctions'][2])
dump(graphDataHistory['X_Junctions'][1])
dump(graphDataHistory['X_Junctions'][2])
print('')
graphDataHistory['mergeNodesToLines'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['mergeNodesToLines'][1])
dump(graphDataHistory['mergeNodesToLines'][2])
dump(graphDataHistory['mergeNodesToLines'][1])
dump(graphDataHistory['mergeNodesToLines'][2])
print('')
graphDataHistory['Merge_Nodes_2'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['Merge_Nodes_2'][1])
dump(graphDataHistory['Merge_Nodes_2'][2])
dump(graphDataHistory['Merge_Nodes_2'][1])
dump(graphDataHistory['Merge_Nodes_2'][2])
print('')
graphDataHistory['optimizeNodes'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['optimizeNodes'][1])
dump(graphDataHistory['optimizeNodes'][2])
dump(graphDataHistory['optimizeNodes'][1])
dump(graphDataHistory['optimizeNodes'][2])
print('')
graphDataHistory['convertToSingleSided'] = {hashNodeData(), hashEdgeData()}
dump(graphDataHistory['convertToSingleSided'][1])
dump(graphDataHistory['convertToSingleSided'][2])
dump(graphDataHistory['convertToSingleSided'][1])
dump(graphDataHistory['convertToSingleSided'][2])
print('')
-- end
-- dump(dist)
-- --]]
-- end
-- -- dump('nodeColors', nodeColors)
-- -- dump('colorCodes', colorCodes)
-- -- dump('nodeColors', nodeColors)
-- -- dump('colorCodes', colorCodes)
-- dump('maxColorCode', maxColorCode)
-- -- dump('colorCodes', colorCodes)
-- dump('maxColorCode', maxColorCode)
-- end
end
dump(dist)
--]]
--]]
-- dump('numOfColorCodes', numOfColorCodes)
--print('onWaypoint')
--dump(args)
@/lua/ge/extensions/util/saveDynamicData.lua
local function onClientStartMission(levelPath)
dump(levelPath)
if levelPath == testLevel then
@/lua/ge/extensions/flowgraph/nodes/vehicle/alignForCoupling.lua
local v2Off = self.mgr.modules.vehicle:getVehicle(v2:getID()).couplerOffset[1]
--dump(self.mgr.modules.vehicle:getVehicle(v1:getID()))
--dump(self.mgr.modules.vehicle:getVehicle(v2:getID()))
--dump(self.mgr.modules.vehicle:getVehicle(v1:getID()))
--dump(self.mgr.modules.vehicle:getVehicle(v2:getID()))
if not v1Off or not v2Off then
@/lua/ge/extensions/editor/gen/ui.lua
for key,p in pairs(aicon) do
-- U.dump(aicon[key], '?? for_icon:'..tostring(aicon[key]))
dicon[key] = editor.texObj('/lua/ge/extensions/editor/gen/assets/_icon/'..(aicon[key][3] or key)..(p.suf or '.png'))
end
-- U.dump(list, '??*********** for_list:'..tp..':'..tostring(#list[1])..':'..tostring(type(list[1])))
-- _dbgone = true
end
-- U.dump(mlist,'?? if_LIST2:'..tp..':'..tostring(meshType)) --type(mlist[1])..':'..tostring(mlist and #mlist or nil))
break
end
-- U.dump(list, '??+++++++++++++++++++++++++++++++++++++++++++++++ mlist:')
-- _dbgone = true
-- U.dump(list)
im.Text('Material')
@/lua/ge/extensions/gameplay/missions/unlocks.lua
log("W", "gameplay_missions_unlocks", "League " .. cond.leagueId .. " has no branchId")
dump(cond)
dumpz(league, 2)
@/lua/ge/extensions/editor/trafficDebug.lua
if im.Button("Dump Data") then
dump(currVeh)
end
@/lua/ge/extensions/editor/gen/lib/jbeam.lua
if nm then
-- dump(cnt[nm], '?? for_PART:'..nm)
local dgroup = {}
inhead = true
-- dump(s, '?? prm:'..i)
if s.beamDamp then
lo('?? g_NEXT:'..n..':'..U.stamp({s[1],s[2]})..'>'..stamp)
-- dump(s, '?? g_NEXT:'..n..':'..U.stamp({s[1],s[2]})..'>'..stamp)
n = n + 1
-- dump(dgroup, '<< fileUp:'..tableSize(dgroup),nil,1)
lo('<< fileUp:'..tableSize(dgroup))
end
-- dump(cnt, '?? parseFile:',nil,1)
return cnt
local vehData = core_vehicle_manager.getVehicleData(id)
-- dump(vehData.ioCtx.preloadedDirs,'?? part2file:'..tostring(vehData))
jbeamIO.startLoading(vehData.ioCtx.preloadedDirs)
-- table.sort(aflex)
-- dump(aflex, '?? AFLEX:')
for key,p in pairs(pvd.vdata.activePartsData) do
local p,f = jbeamIO.getPart(vehData.ioCtx, key)
-- dump(p, '?? part:',nil,2)
-- lo('?? for_part:'..tostring(key)..':'..tostring(f))
p2f[key] = {name = key, file = f, abeam = {}, amesh = {}}
-- dump(p.flexbodies, '??^^^^^^^^^^^^^^^^^ part:'..key)
if p.flexbodies then
else
-- dump(p.flexbodies[i], '?? NO_FB:'..key)
end
-- jTS.processTableWithSchemaDestructive(p, out)
-- dump(sp, '??_____________ out:')
-- dump(p2f[key], '?? part:')
-- dump(sp, '??_____________ out:')
-- dump(p2f[key], '?? part:')
-- break
end
-- dump(pvd.vdata.beams,'?? beams:',nil,2)
for i,b in pairs(pvd.vdata.beams) do
-- if stamp == 'b3rr_rb7rr' or stamp == 'b3ll_rf1l' then
-- dump(b, '??^^^^^^^^^^^^ stamp_t:'..stamp)
-- end
-- if i < 5 then
-- dump(b, '?? for_BEAM:'..i)
-- end
end
-- dump()
-- dump(p2f, '?? p2f:',nil,1)
-- dump()
-- dump(p2f, '?? p2f:',nil,1)
lo('<< part2file:'..tableSize(p2f))
@/lua/ge/extensions/flowgraph/nodes/gameplay/rally/loop/rallyPositionGetter.lua
if sp then
-- dump(sp)
self.pinOut.pos.value = sp.pos
@/lua/ge/extensions/campaign/comics.lua
-- dump(comicPanels)
-- dump(onSpineAnimationFinished_callback)
-- dump(comicPanels)
-- dump(onSpineAnimationFinished_callback)
local audioCallback = function(name, audio)
-- dump(name)
lastVolumes[name] = audio:getVolume()
@/lua/console/bananabench-async.lua
end
--dump(t)
--local diff = t.res[2].beamspersec / t.res[1].beamspersec
print(" `-----' ")
--dump(res)
@/lua/ge/extensions/editor/dynamicDecals/debugSection.lua
if im.Button(string.format("%s##%s", "Reproject Layers", guiId)) then
dump(api.reprojectLayers())
end
if im.Button(string.format("%s##%s", "Dump api.layerStack", guiId)) then
dump(api.getLayerStack())
end
if im.Button(string.format("%s##%s", "getShapeMaterialNames", guiId)) then
dump(api.getShapeMaterialNames())
end
if im.Button(string.format("%s##%s", "getMeshObjectCount", guiId)) then
dump(api.getMeshObjectCount())
end
if im.Button(string.format("%s##%s", "api.getShapeMeshes()", guiId)) then
dump(api.getShapeMeshes())
end
if im.Button(string.format("%s##%s", "dump selection", guiId)) then
dump(editor.selection["dynamicDecalLayer"])
end
if im.Button(string.format("%s##%s", "dump gizmo.transform", guiId)) then
dump(gizmo.transform)
end
if im.Button(string.format("%s##%s", "dump gizmo.transform:getPosition()", guiId)) then
dump(gizmo.transform:getPosition())
end
if im.Button(string.format("%s##%s", "Dump settings.getUsedMaterialNames()", guiId)) then
dump(settings.getUsedMaterialNames())
end
@/lua/ge/extensions/editor/api/dynamicDecals/textures.lua
-- print("tags")
-- dump(tags)
-- print("tagsWithRefs")
-- print("tagsWithRefs")
-- dump(tagsWithRefs)
@/lua/ge/extensions/editor/crawlEditor/trails.lua
FS:removeFile(trail._filePath)
dump('[CRAWL_EDITOR] Deleted trail file: ' .. trail._filePath)
end
@/lua/ge/extensions/flowgraph/manager.lua
for nId, node in pairs(g.nodes) do
--dump(g.id.."/"..nId)
if node:representsGraph() and node:representsGraph().id == graph.id then
-- flatten lists for graphs before deserializing further!
--dump(data.version)
if data.version == 0.1 then
for cId, c in pairs(g.children or {}) do
--dump(cId)
newGraphs[cId] = c
@/lua/ge/extensions/util/procTrack.lua
--dump(totalTS)
if not params.seed then
local r2 = graph.nodes[r2i.index]
--dump(r.name .." : ".. #r.neighbours)
--for _,n in ipairs(r.neighbours) do
roadTS = roadTS..'});';
--dump(roadTS)
end
--dump(candidate.name .. " Is Unfit as end node.")
neighbourIndex = neighbourIndex+1
if not finishNode then -- all edges from this node will result in a graph split, meaning we can never create a closed track, meaning this graph is garbage.
--dump("no finish")
return nil
if current.offset >= #current.neighbours then
-- dump("doing 0ne back, popping ".. path[#path].name)
path[#path].nextIndex=-1
end
--dump("#freeNodes == "..#freeNodes)
if #freeNodes == 0 then -- no more nodes, no lonely nodes :)
end
--dump("currentIndex"..currentIndex)
-- if no such node, we are done.
if #open ~= #freeNodes then
--dump("Would Create Lonely nodes if we added "..nextNode.name)
end
--dump("#open = "..#open .. " #free = "..#freeNodes)
-- if the number of nodes in the open list is not the number of free nodes, we have a separated group!
if nodes[i].force and nodes[i].force.radius then
--dump("Forced radius.")
nodes[i].radius = nodes[i].force.radius
elseif nodes[i].force and nodes[i].force.radiusPercent then
--dump("Forced radiusPercent.")
nodes[i].radius = nodes[i].force.radiusPercent * p.closestNeighbourDist
if nodes[i-1].straight then
--dump(nodes[i-1])
--dump(lrDet)
--dump(nodes[i-1])
--dump(lrDet)
--dump(nodes[i-1].n)
--dump(lrDet)
--dump(nodes[i-1].n)
--dump(nodes[i-2].n)
--dump(nodes[i-1].n)
--dump(nodes[i-2].n)
if math.random() < params.path.gateChance then
if nodes[i-1].force and nodes[i-1].force.gate ~= nil then
-- dump("Forced Gate to "..nodes[i-1].force.gate)
nodes[i-1].radius = 0
if nodes[i-1].force and nodes[i-1].force.flip ~= nil then
--dump("Forced Flip to "..nodes[i-1].force.flip)
nodes[i-1].flipped = nodes[i-1].force.flip
--dump(nodes)
return nodes
--steps = 2
--dump(steps)
if #n.points == 0 then
--dump("MIssing Points?")
end
nv.y = nv.y / length
--dump(nv)
local angle = (math.acos(nv.x) * 180) / math.pi
end
--dump(nodes[i].pass.arcAngleRad)
if steps < 8 then steps = 8 end
--dump(nodes[i].pass.arcAngleRad)
if j % mod == 0 then
local pIndex = math.ceil(#(n.points)/2)
--dump(pIndex)
scenario.nodes['gym_'..i] = {}
--dump(scenario.lapConfig)
if params.moveVehicleIntoPosition then
if params.rollingStart then
--dump("is Rolling Start")
scenario.rollingStart = true
end
--dump("no rolling start")
scenario.rollingStart = false
--dump(scenario.lapConfig)
scenario.initialLapConfig = deepcopy(scenario.lapConfig)
local function makeConcreteRing(pos, radius)
--dump("radius = "..radius)
--radius = radius * 0.66
ret = ret + (-1 + wordIndex) * math.pow(#wordList,(i))
--dump("Add" .. (-1 + wordIndex) * math.pow(#wordList,(i)))
while int > 0 do
--dump((int%(#wordList))+1)
ret = ret .. wordList[(int%(#wordList))+1]
@/lua/ge/extensions/gameplay/missions/proceduralMissionGenerators/timeTrialMissions.lua
end
--dump(hiddenFiles)
local hiddenFileCount = 0
for _, race in ipairs(level.tracks) do
--dump(dumps(race.ignoreAsMission or "fals").." ".. dumps(race.trackName) )
if not race.ignoreAsMission then
--log("I","","INVALID Race from cache: " .. raceId)
--dump(raceFile)
raceFile = nil
@/lua/common/utils/filterchain.lua
local function getVarByNameInScope(components, scope)
--dump('getVarByNameInScope', components, scope)
if #components == 1 then
--dump( (function(a,b,c) return a + b + c end) ( unpack({(function (a, b, c) return a + b + c, 1, 1; end)(1,2,3)}) ))
--[[
})
dump(f:update(0.5, 1))
dump(f:update(0.5, 2))
dump(f:update(0.5, 1))
dump(f:update(0.5, 2))
dump(f:update(0.5, 3))
dump(f:update(0.5, 2))
dump(f:update(0.5, 3))
dump(f:update(0.5, 4))
dump(f:update(0.5, 3))
dump(f:update(0.5, 4))
dump(f:update(0.5, 5))
dump(f:update(0.5, 4))
dump(f:update(0.5, 5))
]]
--mv.foo = 1337
--dump(getVarByName('mv.foo', locals()))
--dump(locals())
timer = timer + dt
dump(led1:update(dt, 1))
--local out = led1:update(dt, 1, 2, 3)
@/lua/ge/extensions/flowgraph/nodes/debug/comment.lua
end
dump(self.te)
end
@/lua/ge/extensions/util/trackBuilder/obstaclePlacer.lua
local name = o.value .. o.variant
--dump(refPoint)
data[name][#data[name]+1] = {
@/lua/common/utils.lua
-- print("original data: " .. tostring(d))
-- dump(d)
-- s = serialize(d)
-- print("restored data: " .. tostring(da))
-- dump(da)
-- sa = serialize(da)
@/lua/ge/extensions/gameplay/rally/notebook/path.lua
if not currCodriverId then
-- dump(currCodriverId)
self:useCodriver(self:getFirstCodriver())
@/lua/common/libs/resty/template.lua
function template.precompile(view, path, strip)
local chunk = dump(template.compile(view), strip ~= false)
if path then
@/lua/vehicle/controller/vehicleController/vehicleController.lua
end
--dump(shiftPointData)
guihooks.trigger("ShiftPointDebugDataChanged", shiftPointData)
--dump(jbeamData)
--dump(shiftPoints)
@/lua/ge/extensions/editor/missionPlaybook.lua
if i < untilIdx then
dump("Instructions:")
dump(e)
dump("Instructions:")
dump(e)
local fun = executeFunctions[e.type] or nop
end
--dump(book.results)
end
end
dump(m.id .. " -> " .. dumps(isTier))
useMission = useMission and isTier
@/lua/ge/extensions/career/modules/delivery/general.lua
}
if not cargo.weight then log("W","","No weight on cargo? " .. dumps(cargo.name)) dump(cargo) end
if interactiveParkingSpots[ps:getPath()] or ap.isInspectSpot or dCargoScreen.isCargoScreenOpen() then
--dump(string.format("%s -> %s", fac.name, name))
--dumpz(ap, 1)
@/lua/ge/extensions/flowgraph/groupHelper.lua
local nodeLookup = tableValuesAsLookupDict(nodeIds)
--dump(nodeLookup)
for id, lnk in pairs(graph.links) do
@/lua/ge/extensions/flowgraph/nodes/ui/onBigmapPoiSelected.lua
self.pinOut.pos.value = self.navPos:toTable()
--dump(self.flags)
table.clear(self.flags)
@/lua/common/jbeam/sections/wheels.lua
--log('D', "jbeam.addWheel","wheel jbeam.")
--dump(wheel)
local node1 = vehicle.nodes[wheel.node1]
--dump(wheel)
-- the rest
--log('D', "jbeam.addMonoHubWheel","wheel jbeam.")
--dump(wheel)
local node1 = vehicle.nodes[wheel.node1]
@/lua/vehicle/powertrain/combustionEngine.lua
device.engineVolumeCoef = 1
--dump(sounds)
sounds.disableOldEngineSounds()
}
--dump(params)
device:setEngineSoundParameterList(device.engineSoundID, params, "engine")
device:setEngineSoundParameterList(device.engineSoundID, params, "engine")
--dump(sounds)
hasNewSounds = true
}
--dump(params)
--dump(jbeamData)
@/lua/ge/extensions/flowgraph/nodes/ui/missionEndScreen.lua
endData = {missionData = missionData, stats = statsData}
--dump(endData)
guihooks.trigger('ChangeState', {state = 'scenario-end', params = endData})
@/lua/vehicle/extensions/dynamicVehicleData.lua
--print("data pre clearing:")
--dump(data)
for _, v in pairs(whiteList) do
--print("data post clearing:")
--dump(data)
@/lua/ge/extensions/flowgraph/modules/prefabModule.lua
for k, v in pairs(vehicleTransforms) do
--dump("Extracting object: " .. i)
local veh = scenetree.findObjectById(k)
@/lua/common/particles.lua
--dump(mix)
end
--dump(materialsMap)
end
@/lua/common/csvlib.lua
function csvWriter:dump()
return tostring(self.buf)
end
writeFile(filename, self:dump())
return filename
@/lua/ge/extensions/gameplay/rally/loop/rallyAttempts.lua
}
dump(vData)
attempt["vehicle"] = vData
@/lua/vehicle/ai.lua
local function dumpParameters()
dump(parameters)
dump('aggression = ', aggression)
dump(parameters)
dump('aggression = ', aggression)
end
local wp3 = path[i+1]
--dump('---- > in', i, path[i])
if not wp1 and not wp3 then
if not wp1 and not wp3 then
--dump('!!!!!!!!!!!!!!', path, objectId)
return mapData.positions[wp2]:copy()
local e2P1, e2P2 = mapData:getEdgePositions(wp2, wp3)
--dump(wp1, wp2, wp3, e1P2:squaredDistance(e2P1))
if e1P2:squaredDistance(e2P1) < 0.005 then
if e1P2:squaredDistance(e2P1) < 0.005 then
--dump('b0')
return (e1P2 + e2P1) * 0.5
-- segments are parallel
--dump('b1')
return (e1P2 + e2P1) * 0.5
-- intersection is within the (radius augmented at P2) e1 and e2 segments
--dump('b2', 'e1Xnorm = ', e1Xnorm, 'e2Xnorm = ', e2Xnorm)
local p1 = linePointFromXnorm(e1P1, e1P2, e1Xnorm)
-- intersection is within (radius augmented at P2) e1 segment and not furnter than the end of e2 (enures that it is not over segment 2 end, if it is too short)
--dump('b3', 'e1Xnorm = ', e1Xnorm, 'e2Xnorm = ', e2Xnorm)
local segLen = e1P2:distance(e1P1)
-- intersection is within (radius augmented at P2) e2 segment and infront of e1P1
--dump('b4', 'e1Xnorm = ', e1Xnorm, 'e2Xnorm = ', e2Xnorm)
local segLen = e2P1:distance(e2P2)
-- intersection is over segment 2 end or before segment 1 start (particular case)
--dump('b5')
return (e1P2 + e2P1) * 0.5
-- intersection is between segments 1 and 2 but outside of radii extensions
--dump('b6')
local p1 = linePointFromXnorm(e1P1, e1P2, e1Xnorm)
-- plan.trafficTargetSpeed = max(plan.trafficTargetSpeed, 0)
-- --dump(plan.trafficMinProjSpeed, plan.distances, dv, plan.trafficTargetSpeed, ((plan.distances - ego.race.d) / ego.race.Td), - ego.race.kp * max(0, dv))
--else
local curvatureZ = min(inCurvature(v1z, v2z), inCurvature(v1z, v3z))
--dump(i,'curvature', curvature, 'Zcurv', curvatureZ)
-- end
-- dump(objectId, edgeCollisionIdx, path[edgeCollisionIdx], path[edgeCollisionIdx+1])
-- end
local rounds = twt.idx - 1
dump("rounds in debug", rounds)
-- debugDrawer:drawSphere(0.3, ego.pos, color(255,255,0,255))
-- dump(obj)
-- local test = obj:getCornerPosition(0)
-- dump(test)
-- debugDrawer:drawSphere(0.1, frontPos, color(255,255,0,255))
-- local test2 = obj:getFrontPositionRelative()
-- dump(test2)
-- debugDrawer:drawSphere(0.3, ego.wheelBase[2], color(255,255,0,255))
if k ~= objectId then
--dump(v.pos)
obj.debugDrawProxy:drawSphere(0.2, v.pos, color(0, 0, 255, 255))
obj.debugDrawProxy:drawSphere(0.2, vPos + v.vel * dt, color(0, 255, 0, 255))
--dump(obj:getObjectDirectionVector(k))
--dump(obj:getObjectDirectionVectorUp(k))
--dump(obj:getObjectDirectionVector(k))
--dump(obj:getObjectDirectionVectorUp(k))
end
local function dumpCurrentRoute()
dump(currentRoute)
end
@/lua/ge/extensions/career/modules/delivery/progress.lua
end
--dump(dropOffDataStatus)
guihooks.trigger("SetDeliveryDropOffCargoSelection", dropOffDataStatus)
confirmedDropOffData.cargo = {}
--dump(confirmedDropOffs)
for _, elem in ipairs(confirmedDropOffData.parcelIdElems) do
@/lua/ge/extensions/editor/flowgraphEditor.lua
local closed = ( not editor.isWindowVisible(main.windowName)) --and (not editor.isWindowVisible(executionView.windowName))
--dump(closed)
if closed then
if im.MenuItem1("Encode Clipboard...") then
dump(lpack.encode(M.copyData))
end
autoSaveTimer = autoSaveTimer - dtReal
--dump(mgr.name)
im.PushStyleVar2(im.StyleVar_WindowPadding, im.ImVec2(8, 8))
@/lua/ge/extensions/util/booster.lua
print("Booster triggered")
dump(data)
@/lua/ge/extensions/core/vehicleMirrors.lua
vehicleMirrorData = data
--dump({'got config', id, data})
@/lua/ge/extensions/freeroam/freeroamConfigurator.lua
M.doubleClickOverride = function(item)
dump(item)
end
@/lua/common/jbeam/variables.lua
if dict[v.name] then
-- dump({'val=',v.default, 'overwrites=', dest[dict[v.name]].default})
dest[dict[v.name]] = v
local function unifyComponents(vehicle, svars, target, source_raw, level, slotOptions, partPath, slot)
--dump(slot.variables or {})
for sectionKey, section in pairs(source_raw) do
varStack[tostring(part)] = svars
--dump(varStack)
@/lua/ge/extensions/util/export.lua
-- dump(rootNodes)
--dump(filepath, filepathIn, bufferIDTexture, bufferViewID, image, imageId)
if not maxLayers then maxLayers=3 end
-- dump(info)
for i=0,maxLayers-1 do
partToFlexMesh[path][prop.mesh] = true
-- dump(prop)
end
--chunk[1] Binary data / buffers
--dump(totalBinBufSize + fourByteAlignPaddingSize(totalBinBufSize))
--dump(sepbytes(totalBinBufSize + fourByteAlignPaddingSize(totalBinBufSize)))
--dump(totalBinBufSize + fourByteAlignPaddingSize(totalBinBufSize))
--dump(sepbytes(totalBinBufSize + fourByteAlignPaddingSize(totalBinBufSize)))
f:write( string.char(sepbytes(totalBinBufSize + fourByteAlignPaddingSize(totalBinBufSize))) ) --size
@/lua/ge/extensions/editor/flowgraph/nodePreview.lua
--dump(self.hover)
--self.popupMousePos.x = self.popupMousePos.x + 300
@/lua/ge/extensions/util/maptiles.lua
maxY = terrainPosition.y + terrainSize
dump(minX, maxX, minY, maxY)
-- Calculate bounding box for all map nodes
maxY = math.ceil( maxY + margin)
dump(minX, maxX, minY, maxY)
dump(minX, maxX, minY, maxY)
end
currentTileIndex = tile.yIndex * totalTilesX + tile.xIndex + 1
dump(tile)
frameCounter = 0 -- Reset frame counter
@/lua/ge/extensions/flowgraph/graph.lua
table.sort(children, idSort)
--dump(children)
return children
end
--dump("Deleting..................................................................")
--dumpz(node, 1)
@/lua/ge/extensions/gameplay/delivery/delivery.lua
if not vData then
dump("No vData?!")
return nil
@/lua/ge/extensions/gameplay/crashTest/crashTestBoundaries.lua
setParameters({filePath = getMissionRelativePath("boundsStep" .. stepData.id .. ".sites.json")})
dump("new step")
else
@/lua/ge/extensions/flowgraph/nodes/gameplay/rally/vehicleStoppedNearPlane.lua
-- dump("isStopped: " .. tostring(isStopped))
-- dump("isNearPlane: " .. tostring(isNearPlane) .. " signedDistance: " .. tostring(signedDistance))
-- dump("isStopped: " .. tostring(isStopped))
-- dump("isNearPlane: " .. tostring(isNearPlane) .. " signedDistance: " .. tostring(signedDistance))
@/lua/ge/extensions/util/trackBuilder/materialUtil.lua
loadMaterial(letter)
dump(currentMaterials[letter])
setSingleMaterial(letter,originalMaterials[letter])
setSingleMaterial(letter,originalMaterials[letter])
dump(currentMaterials[letter])
end
@/lua/vehicle/extensions/api.lua
--print("got request:")
--dump(request)
if not request.uri then return end -- returns 500
local data = prepareEditorData()
--dump(data)
return data
--local res = jsonRequest('http://localhost:23716/v1/register', {server = bindHost, port = port})
--dump(res)
end
local function onVehicleLoaded()
--dump(prepareEditorData())
end
@/lua/ge/extensions/gameplay/missions/missions.lua
local _, missionId, _ = path.split(missionDir)
--dump(missionId)
missionId = string.sub(missionDir, #missionsDir+1)
for _,missionInfo in ipairs(FS:findFiles(missionsDir, 'info.json', -1, false, true)) do
--dump(missionInfo)
local missionDir, _, _ = path.split(missionInfo)
@/lua/ge/extensions/gameplay/rally/notebook/test/testNotebook.lua
-- dump(notebook.pacenotes.sorted[1], 2)
testStructured_serialize()
dump(assertCounts)
end
@/lua/ge/extensions/editor/scriptAIManager.lua
if data then
--dump({' * got info: ', vehId, data})
data.percent = 0
@/lua/vehicle/controller/couplings/fifthwheel.lua
end
--dump(kingpinCache[detachingKingpinObjId])
if not detachingKingpinObjId or not detachingKingpinNodeCid or not kingpinCache[detachingKingpinObjId] or not kingpinCache[detachingKingpinObjId][detachingKingpinNodeCid] or kingpinCache[detachingKingpinObjId][detachingKingpinNodeCid].distance > 0.6 then
@/lua/ge/extensions/flowgraph/states.lua
function C:addStateFromPortedNode(pnode)
--dump("Creating State: " .. node.targetGraph.name)
local node = pnode.node
for _, lnk in ipairs(sourced) do
--dump("current from sourced: " .. lnk.simple)
local exitReached = nil
for _, current in ipairs(open) do
--dump("current from open: " .. current.simple)
local currentTargetNode = nodes[current.link.targetNode.id]
for _, sel in ipairs(selected) do
--dump("Found sel! " .. sel.simple)
table.insert(successors, sel)
table.insert(deps, state.extProxy.extName)
--dump(state.id .. dumps(state.ports))
end
@/lua/ge/extensions/editor/dynamicDecals/docs.lua
M.selectSection(docsSections.children[1].name, true)
-- dump(docsSections)
end
@/lua/vehicle/extensions/debug/advancedExternalDebug.lua
if data then
--dump(data)
local splits = split(data, "->")
local configTable = jsonDecode(controllerConfig, "CMU SetConfig")
--dump(configTable)
receiver.setConfig(configTable)
local paramTable = jsonDecode(param, "CMU SetProperty")
--dump(paramTable)
receiver.setParameters(paramTable)
@/lua/ge/extensions/flowgraph/modules/vehicleModule.lua
--core_vehicleBridge.requestValue(veh,function(...) dump(...) end, 'couplerOffset', 'tow_hitch')
-- instantly get the damage tracker
@/ui/modules/quickrace/quickrace.js
//bngApi.engineLua(luaCmd)
// bngApi.engineLua("dump(" + bngApi.serializeToLua(track) + ")")
@/lua/ge/extensions/core/checkpoints.lua
-- dump(vehicleCheckpoints[vehicleId])
end
helper.setAiPath(arg)
-- dump(arg)
end
M.state.aiVehiclePath[vehId] = arg
-- dump(arg)
end
-- log('I', logTag,'onRaceWaypointReached called')
-- dump(data)
local vehWpData = scenario_waypoints.getVehicleWaypointData(data.vehicleId)
local vehWpData = scenario_waypoints.getVehicleWaypointData(data.vehicleId)
-- dump(vehWpData)
if aiVehiclePath[data.vehicleId] then
-- dump(aiVehiclePath[data.vehicleId])
-- dump(data.waypointName)
-- dump(aiVehiclePath[data.vehicleId])
-- dump(data.waypointName)
local waypoints = aiVehiclePath[data.vehicleId].waypoints
end
-- dump(aiVehiclePath[data.vehicleId])
end
data.aiVehiclePath = convertVehicleIdKeysToVehicleNameKeys(state.aiVehiclePath)
-- dump(data)
--writeFile("checkpoints.txt", dumps(data))
-- log('I', logTag, msg)
-- dump(state)
if not M.state.vehicleCheckpoints[vehId] then
-- log('I', logTag, msg)
-- dump(state)
@/lua/ge/extensions/ui/liveryEditor/layers/group.lua
M.setColor = function(layer, rgbaArray)
dump("group setColor", rgbaArray)
-- for k, childLayer in ipairs(layer.children) do
@/lua/ge/extensions/editor/materialEditor.lua
-- print(string.format("%0.2f", timer:stopAndReset()))
-- dump(tags)
end
@/lua/ge/extensions/flowgraph/nodes/macro/integrated.lua
function C:_onDeserialized(nodeData)
--dump("_onDeserialized")
--dump(nodeData)
--dump("_onDeserialized")
--dump(nodeData)
self.name = nodeData.name
@/lua/ge/extensions/gameplay/missions/missionManager.lua
mission._isOngoing = true -- in case onStart guys ask about our own state - yes, we're kinda ongoing now...
--dump("Mission now _isOngoing : " .. dumps(mission.id))
if mission:onStart() then
local function attemptAbandonMissionWithFade(mission, force, abandonButtonPressed)
--dump("attemptAbandonMissionWithFade")
--print(debug.tracesimple())
local function stop(mission, data)
--dump("stop")
--print(debug.tracesimple())
log("E","","This step timed out ("..(stepToHandle.timeout or 120).."s). Step will be set to complete.")
--dump(stepToHandle)
--dump(taskData)
--dump(stepToHandle)
--dump(taskData)
stepToHandle.complete = true
@/lua/ge/extensions/core/settings/graphic.lua
if newState.GraphicDisplayDriver and newState.GraphicDisplayDriver ~= M.selected_displayDriver then
-- dump(tostring(M.selected_displayDriver) .. ' is now '.. newState.GraphicDisplayDriver)
if graphicsOptions.GraphicDisplayDriver and type(graphicsOptions.GraphicDisplayDriver.set) == 'function' then
if newState.GraphicDisplayModes and newState.GraphicDisplayModes ~= M.selected_displayMode then
-- dump(tostring(M.selected_displayMode) .. ' is now '.. newState.GraphicDisplayModes)
if graphicsOptions.GraphicDisplayModes and type(graphicsOptions.GraphicDisplayModes.set) == 'function' then
if newState.GraphicDisplayResolutions and newState.GraphicDisplayResolutions ~= M.selected_resolution then
-- dump(tostring(M.selected_resolution) .. ' is now '.. newState.GraphicDisplayResolutions)
if graphicsOptions.GraphicDisplayResolutions and type(graphicsOptions.GraphicDisplayResolutions.set) == 'function' then
if newState.GraphicDisplayRefreshRates and newState.GraphicDisplayRefreshRates ~= M.selected_refreshRate then
-- dump(tostring(M.selected_refreshRate) .. ' is now '.. newState.GraphicDisplayRefreshRates)
if graphicsOptions.GraphicDisplayRefreshRates and type(graphicsOptions.GraphicDisplayRefreshRates.set) == 'function' then
@/gameplay/missionTypes/simpleLapconfigScenario/customNodes/SteamAchievementNode.lua
function C:work()
dump(self.pinIn.passed.value)
dump(self.mgr.activity.id)
dump(self.pinIn.passed.value)
dump(self.mgr.activity.id)
if not self.pinIn.passed.value then return end
@/lua/vehicle/extensions/tech/ACC.lua
for i = 1, #A do
dump(A[i])
end
@/lua/common/jbeam/sections/mirror.lua
log("E","proc","probably old data!!!")
dump(v)
end
@/lua/ge/extensions/scenario/quickRace.lua
if not sc.track then return end
--dump(sc.track.tod .. " = TOD")
if sc.track.tod == 0 or sc.track.tod == 1 or sc.track.tod == 8 then
end
--dump(wpInfo)
--dump(times)
--dump(wpInfo)
--dump(times)
local scenario = scenario_scenarios.getScenario()
--dump("place is "..place)
local incIndexes = {}
end
--dump(incIndexes)
for k,v in ipairs(incIndexes) do
scenario.highscores.singleRound[#scenario.highscores.singleRound+1] = place
--dump(scenario.highscores.singleRound)
local function changeTimeTrialConfig()
-- dump('toggleTimeTrialsScreen called....')
if M.timeTrialOpen == nil then
@/lua/vehicle/controller/powertrainControl/activeCenterDiff.lua
local steeringInput = abs(electrics.values.steering_input)
--dump(electrics.values)
@/lua/ge/extensions/editor/perfProfiler.lua
local lvl, annotationFilename = string.match(dir,".-([^/]+)/([^/]+)/$")
dump(lvl, annotationFilename)
if lvl and annotationFilename then
local file = "/levels/"..lvl.."/perfRecordingCampaths/"..annotationFilename..".perfAnnotation.json"
dump(file)
if FS:fileExists(file) then
@/lua/ge/extensions/editor/util/transformUtil.lua
--dumpz(self, 2)
--dump(self:correctEditMode())
--dump(editor.editMode and editor.editMode.displayName)
--dump(self:correctEditMode())
--dump(editor.editMode and editor.editMode.displayName)
--print(debug.tracesimple())
local height = elemCount * elemHeight / scale + (elemCount - 2) * spacing
--dump(elemCount, spacing, elemHeight)
local prePos = im.GetCursorPos()
@/lua/ge/extensions/flowgraph/modules/buttonModule.lua
function C:executionStopped()
-- dump("Clearing Buttons Table")
self:clear()
@/lua/ge/extensions/scenario/raceGoals.lua
end
--dump(scenario.goals.vehicles)
end
@/lua/vehicle/powertrain.lua
end
-- dump(deviceStream)
gui.send("powertrainDeviceData", streamData)
--dump(devices)
guihooks.trigger("PowertrainDeviceTreeChanged", {devices = devices, maxPower = maxPower, maxTorque = maxTorque})
--dump(availableDeviceFactories)
--dump(deviceFactories)
local devicesSorted = tableKeysSorted(deviceLookup)
--dump(beamTriggers)
--dump(beamBrokenEvents)
--dump(beamTriggers)
--dump(beamBrokenEvents)
-- for k,v in pairs(powertrainDevices) do
-- end
--dump(speedOrderedDevices)
--dump(breakTriggerBeams)
--dump(breakTriggerBeamLookup)
--dump(breakTriggerBeams)
--dump(breakTriggerBeamLookup)
local deviceNames = breakTriggerBeams[id]
--dump(deviceNames)
for _, name in ipairs(deviceNames) do
@/lua/ge/extensions/editor/flowgraph/variables.lua
self.addVariableSettings = { target = 1 , addAnother = editor.getPreference("flowgraph.general.repeatVariableCreation")}
--dump(self.addVariableSettings)
end
@/lua/ge/extensions/flowgraph/basenode.lua
-- print(debug.tracesimple())
--dump(nodeData)
end
@/lua/ge/extensions/editor/buildingEditor.lua
-- lo(type(o)..':'..type(e)..':'..o..':'..tostring(e))
local lt = U.dump(e, nil, 1)
-- lo('?? dret:'..lt)
jointpath[#jointpath + 1] = 0
-- U.dump(path, '?? path:'..#apath)
end
--- find free nodes
-- U.dump(jointpath, '?? JPATH:')
-- U.dump(U.index(jointpath, 7), '?? i_7:')
-- U.dump(jointpath, '?? JPATH:')
-- U.dump(U.index(jointpath, 7), '?? i_7:')
local afree = forOdd()
path = { afree[1] }
U.dump(afree, '?? afree:')
U.dump(apath[#apath], '?? path:'..path[1])
U.dump(afree, '?? afree:')
U.dump(apath[#apath], '?? path:'..path[1])
-- path = { afree[math.random(#afree)] }
if #afree > 0 then
U.dump(afree, '?? MORE:')
--TODO: increase nmax
-- apath[#apath + 1] = path
U.dump(path, '<< pathsUp:'..#jointpath..'/'..#anode..':'..#apath)
end
-- U.dump(aang, '<< linkOrder:'..angp)
return aang
--- pick opposite branch
-- U.dump(aang, '?? aang:')
local imi
if ialt ~= nil then
U.dump(aang, '??********** FOR_SC:'..sc..':'..aang[imi][1]..'>'..aang[ialt][1])
end
end
U.dump(astamp, '<< stem:')
local path = rd.path
U.dump(path)
local newRoadID = editor.createRoad(
end
U.dump(dec2path, '?? DEC2PATH:')
rd.dec2path = dec2path
local inpath = U.index(r.path, icirc)
-- U.dump(inpath, '?? inpath:'..i)
-- U.dump(r.apin, '?? r:'..i)
-- U.dump(inpath, '?? inpath:'..i)
-- U.dump(r.apin, '?? r:'..i)
for _,j in pairs(inpath) do
end
U.dump(inedge, '?? inedge')
-- get star of vectors
end
U.dump(adir, '?? adir:')
local aang = U.fanOrder(adir)
local aang = U.fanOrder(adir)
U.dump(aang, '?? aang:')
-- for o = 3,3 do
-- U.dump(hpin,'?? hpin:')
local hmap, apin = av2hmap(edec, hpin)
local hmap, apin = av2hmap(edec, hpin)
U.dump(hmap,'?? hmap_PRE:')
U.dump(apin,'?? apin_PRE:')
U.dump(hmap,'?? hmap_PRE:')
U.dump(apin,'?? apin_PRE:')
--- mesh
local inpath = U.index(r.path, icirc)
U.dump(inpath,'?? inpath:'..icirc..':'..tostring(cpos)..' rid:'..tostring(r.id))
local indec = {}
local decal = scenetree.findObjectById(r.id)
U.dump(inedge[i], '?? junctionUp_inedge:'..i)
lo('?? edge_0:'..tostring(r.av[1])..':'..tostring(r.av[r.avstep])..':'..tostring(decal:getMiddleEdgePosition(0)))
end
-- U.dump(aee, '?? exs:')
aexit[i] = aee
end
U.dump(aexit, '?? exs:')
-- get branches
local aang = U.fanOrder(adir)
U.dump(aang, '??_______________ aang:')
local exin = aexit[d2ri[1]][d2ri[2]]
-- U.dump(exout, '?? for_exo:'..o)
-- U.dump(exin, '?? for_exi:'..o)
-- U.dump(exout, '?? for_exo:'..o)
-- U.dump(exin, '?? for_exi:'..o)
--- exit position
-- apin[4][2] = 1
U.dump(hmap,'?? E_hmap:')
U.dump(apin,'?? E_apin:')
U.dump(hmap,'?? E_hmap:')
U.dump(apin,'?? E_apin:')
-- fromAV(edec, 0, ro, exout.ei)
hmap, apin = Net.hmap4decal(edec, rdinfo.av, rdinfo.avstep)
-- U.dump(hmap, '?? hmap_up:')
-- U.dump(apin, '?? apin_up:')
-- U.dump(hmap, '?? hmap_up:')
-- U.dump(apin, '?? apin_up:')
--- update decal
--- update decal
-- U.dump(hmap, '?? E_hmap:')
-- U.dump(apin, '?? E_apin:')
-- U.dump(hmap, '?? E_hmap:')
-- U.dump(apin, '?? E_apin:')
rdinfo.id = Net.decalUpdate(edec, hmap, apin, true)
if e.meshid == idobj then
-- U.dump(e, '?? for_out:')
ro = e
if e.to[1] == ro.to[1] and e.to[2] == ro.to[2] and e.meshid ~= idobj then
-- U.dump(e, '?? for_in:')
ri = e
})
U.dump(hmap, '?? PREMESH_hm:')
U.dump(apin, '?? PREMESH_apin:')
U.dump(hmap, '?? PREMESH_hm:')
U.dump(apin, '?? PREMESH_apin:')
local rdinfo = {id = dec:getID(), meshid = nil,
if dbg == true then
U.dump(road.apin, '?? mesh_apin:'..nsec)
end
local levels = levelsUp(dec, #list2 - 1)
U.dump(levels, '?? LEVELS:')
roads[#roads + 1] = {
local hmap, apin = {}, {}
U.dump(levels, '?? LEV:')
U.dump(r.dec2path, '?? dec2path:'..nsec)
U.dump(levels, '?? LEV:')
U.dump(r.dec2path, '?? dec2path:'..nsec)
local cdec = 1
lo('?? PRE_UP: nsec='..nsec..' adec='..#adec..':'..tostring(rd)..'::'..#hmap..'::'..tostring(#r.apin))
U.dump(hmap, '?? hmap:')
U.dump(r.apin, '?? apin:')
U.dump(hmap, '?? hmap:')
U.dump(r.apin, '?? apin:')
local id = Net.decalUpdate(rd, hmap, r.apin) --, true)
end
U.dump(dec, '<< toDecals:'..#roads)
end
local fout
local function dump(node, yes)
-- lo('>> dump:'..tostring(yes)..':'..node.stamp)
-- lo('?? FOR_2:'..tostring(ang)..':'..tostring(anode[#anode].pos)..':'..tostring(anode[#anode].ang))
-- U.dump(anode[#anode], '?? FOR_2:'..tostring(ang))
edges.astamp[#edges.astamp + 1] = U.stamp({1, 2})
dump(anode[1])
dump(anode[2])
dump(anode[1])
dump(anode[2])
lo('!! NO_PAIRS:'..i..'/'..nnode..':'..#anode)
U.dump(edges.astamp)
U.dump(edges.infaces)
U.dump(edges.astamp)
U.dump(edges.infaces)
return
dump(anode[#anode])
end
end
U.dump(edges.astamp)
lo('<< circleSeed:'..#anode)
@/lua/ge/extensions/core/flowgraphManager.lua
M.onFlowgraphSceneObjectAdd = function(id, name, fgPath)
dump(string.format("Added FGSO: %s, ID: %d, fgPath: %s ", name or '', id or 0, fgPath or ''))
end
M.onFlowgraphSceneObjectRemove = function(id, name, fgPath)
dump(string.format("Removed FGSO: %s, ID: %d, fgPath: %s ", name or '', id or 0, fgPath or ''))
end
M.onFlowgraphSceneObjectChanged = function(id, name, fgPath)
dump(string.format("Changed FGSO: %s, ID: %d, fgPath: %s ", name or '', id or 0, fgPath or ''))
end