TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
v C++ potřebuji řádek
POINT apt[156]{}
nahradit odkazem na strukturu bodů vektoru, který mám uložen v paměti (z C++ volám vlastní funkci v assembleru) něčím jako:
POINT má_adresa_na_pole_bodů[*(DWORD *)(pocet)]
kde je "počet" pointer na adresu paměti s počtem bodů a "má_adresa_na_pole_bodů" je DWORDLONG pointer (64 bit) na začátek struktury bodů v paměti.
Jak na to ?
POINT apt[156]{} - ty složený závorky tam opravdu patří? Tenhle zápis vidím poprvé. Bez nich by to bylo pole o 156 prvcích a apt by byl ukazatel na první prvek pole.
hu
#3 gna
Ty složené závorky tam asi být nemusí, ale překladač s tím nemá problém.
Jak pracovat se strukturou buodů vím, o to mi nejde. Jak jsem psal z C++ volám vlastní funkci v x64 assembleru, která má data (x, y) připraví v paměti RAM. Pamět RAM si pro to alokuji pomocí funkce VirtualAlloc. Při vynášení bodů pomocí funkce
Návštěvník
Nahlásit jako SPAM
IP: 89.177.163.–
Guru
Polyline(hdc, apt, 156);
potřebuji v proměnné "apt", nastavit odkaz na místo v paměti RAM, kde mám data uložena. Jde tedy o to nějak "vnutit" proměnné apt adresu RAM paměti, kterou mám k dispozici.
#2 hlucheucho
Grafoman
God of flame
#include <iostream>
class Point {
public:
int x;
};
int main()
{
Point a[100];
Point b[100]{};
std::cout << "Point a[n]; => ";
for (auto& item : a) std::cout << item.x << " ";
std::cout << "\n";
std::cout << "Point b[n]{}; => ";
for (auto& item : b) std::cout << item.x << " ";
std::cout << "\n";
}
A vysledek je:
Point a[n]; => 0 0 -752332996 32679 -750305280 32679 725871085 0 2 0 6 0 -750307888 32679 -752330570 32679 -755464504 32679 -1097450912 32764 -759550672 32679 -1097450640 32764 -759531304 32679 11341735 0 -1097450656 32764 -752330191 32679 0 0 -750307768 32679 -750304016 32679 4195515 0 -759497272 32679 4195152 0 0 1 807 1 1 0 -1097450456 32764 -1097450496 32764 -750307768 32679 1 0 -750127840 32679 -750128696 32679 -752330191 32679 0 0 -750307768 32679 1 32679 0 0 1 0 -750128696 32679 -755553232 32679 -750305280 32679 -1 0 -752415072 32679 0 0 -750127840 32679 -1097450640 32764 -1097450656 32764 725871085 0 4195515 0 -1 0 -752383744 32679
Point b[n]{}; => 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Pokud ma trida Point defaultni konstruktor, nebo ma rovnou defaultni hodnotu pro x, tak mezi nimi neni rozdil. Taktez se to takto chova u POD typu. Slozena zavorka se stara o zavolani defaultniho konstruktoru, coz znamena pro POD typy 0 a tak dale.
#4 Kevil
Z tveho popisu sem nejak nepochopil, jestli se snazis volat ten VirtualAlloc uvnitr assemblerovske funkce a chces pak predat adresu do volajiciho funkce. Nejake kratke "funkcni" ukazky kodu by nebyly od veci.
#6 gna
Díky, to je skoro přesně to, co jsem potřeboval. Teď mi to již ukazuje správně na data v paměti, ale chybí tam ještě, jak zadat počet bodů.
Původně jsem tam měl natvrdo:
POINT apt[156];
teď mi sice apt odkazuje správně na data v paměti, použit reálný kód:
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8);
ale struktura POINT neví, kolik bodů tam je. Potřebuji ještě předat odkaz na DWORD v paměti s počtem bodů.
#7 KIIV
VirtualAlloc volám z C++ a adresu pak předám při volání ASM funkci (např. Funkce_Uprav). Alokuji 7 GB do kterých načtu 6 GB externí soubor s daty, který obsahuje 50 mil. řádků. Soubor musím načíst na 3x, nepodařilo se mi přijít na to, jak ho načíst najednou, to ale není žádný problém. načtení trvá cca 3 sekundy. Na notebooku mám 24 GB RAM. Část funkčního kódu pro alokaci RAM a načtení souboru:
_int64 FileSize(const wchar_t* name)
{
WIN32_FILE_ATTRIBUTE_DATA fad;
if (!GetFileAttributesEx(name, GetFileExInfoStandard, &fad))
return -1; // error condition, could call GetLastError to find out more
LARGE_INTEGER size;
size.HighPart = fad.nFileSizeHigh;
size.LowPart = fad.nFileSizeLow;
return size.QuadPart;
}
VOID OnPaint(HDC hdc)
{
delka = FileSize(fname); // 64 bitů
zbyva_nacist = delka;
printf("%lli\n\n", FileSize(fname));
//* Zkusíme otevřít soubor pro čtení *//
HANDLE handle = CreateFile(fname, GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
//if (handle == INVALID_HANDLE_VALUE)
// report_error("Unable to open input file!\n");
//* Alokujeme pamět pro celý soubor *//
static const SIZE_T giga = 1024 * 1024 * 1024;
static const SIZE_T size = 7 * giga;
BYTE* ptr = static_cast<BYTE*>(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
/*if (ptr == nullptr) {
std::cout << "Chyba pri alokaci pameti\n";
return 1;
}*/
std::cout << "Pamet alokovana\n";
BYTE* bsrc = ptr;
//* Načteme soubor *//
DWORD bytes_read;
for (int i = 1; i <= 3; i++) {
if (i < 3) {
cti_znaku = cti_blok;
}
else
{
cti_znaku = delka - nacteno;
}
ReadFile(handle, ptr, cti_znaku, &bytes_read, nullptr);
nacteno += bytes_read;
ptr += bytes_read;
}
CloseHandle(handle);
// Upravíme načtená data v poli
adresa = (__int64)bsrc;
__int64 result = Funkce_Uprav(adresa);ale struktura POINT neví, kolik bodů tam je. Potřebuji ještě předat odkaz na DWORD v paměti s počtem bodů.
To neví nikdy. Proto se třeba do té PolyLine zadává počet samostatně. Z toho popisu se zdálo, že už tu hodnotu někde máš. Pokud ne, tak si na to udělej proměnnou a šoupni to tam.
#11 Kevil
Upravil jsem na reálný kód:
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8)[*(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4)];
kde údaje v závorkách ukazají na správné místo paměti, první je odkaz na souřadnice bodů a druhý odkaz na počet bodů = 2 315. Překlad proběhl bez závad, ale ve struktuře je místo počtu bodů 0, páry bodů proto nejsou vidět.
Pro vysvětlení to x = 8 udává počet nalezených bojí, jejichž trasy chci pak pomocí Polyline vykreslit. Než se to podaří rozchodit, tak nyní pracuji pouze s daty první bóje. Data mám v paměti uložena ve tvaru DWORD od bsrc + x01719F0F6B + 4: počet bójí (8), ID bójí (8x), počet bodů pro bóji (ID=1, ID=2,...) a pak vlastní souřadnice bodů, nejdříve x1, y1, x2, y2... pro bóji ID=1 atd.
#12 Kevil
Jaký počet ve struktuře? Jediná struktura tady je POINT a ta obsahuje jen souřadnice X a Y.
Funkci PolyLine předáš jedním parametrem ukazatel na ty body a dalším parametrem jejich počet.
To přetypování, jak jsem ho napsal je kompletní. Velikost tam nikde není a nebude.
POINT *body = (POINT*) adresa_bodu;
int pocet = (int) *(DWORD*) adresa_poctu;
PolyLine(hdc, body, pocet);#14 MilanL
hele v první reakci jsem se drobet zamotal do zadání
struktura v paměti
N = počet bójí, ID1, ID2, ID3 ....IDN, ID1bodů, ID2bodů .. IDNbodů, [ID1body], [ID2body] .. [IDNbody] ?
pak ty adresy musíš počítat trošku jinak.
INT boje_pocet = (INT) *(DWORD *)(bsrc + 0x01719F0F6B + 4)];
DWORD *boje_ID = (DWORD*)(bsrc + 0x01719F0F6B + 8);
DWORD *boje_poctyBodu = (DWORD*)(bsrc + 0x01719F0F6B + 8 + 4 * boje_pocet);
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 + 2 * 4 * boje_pocet);
Polyline(hdc, apt, *boje_poctyBodu);
pro každou další boji je pak třeba přidat posun o počty bodu předchozi Bóje
apt += boje_poctyBodu * sizeof(POINT));
boje_poctyBodu++;
Polyline(hdc, apt, *boje_poctyBodu);
možná bude třeba ještě něco přetypovat podle potřeb, např ten ukazatel na počet bodů
snad tam nemám moc chyb.
#16 MilanL
Ve výpočtech odkazů není chyba, zkontroloval jsem si to. Problém je, že nefungují odkazy na POINT do paměti podle pokynů výše:
INT32 LAT[156]{ -10127, -10291, -11002, -11149, -10807, -9789, -8948, -8328, -8183, -7918, -7259, -6590, -5993, -7324, -8584, -8876, -8603, -8262, -8858, -8326, -7710, -8189, -7419, -6292, -5564, -5227, -4379, -3494, -3382, -3298, -4022, -4732, -3894, -4604, -6124, -6672, -6904, -7157, -7512, -7987, -8552, -9248, -10438, -10727, -11218, -11566, -12788, -12717, -12070, -11746, -11839, -11238, -11477, -12224, -12864, -14048, -14053, -13786, -14131, -14516, -14395, -14562, -14536, -14487, -14604, -14514, -14833, -14992, -15294, -15153, -15899, -16565, -17287, -17540, -18308, -18508, -18127, -18594, -19131, -19656, -21120, -21738, -21998, -20052, -19360, -19651, -22041, -26186, -25980, -24102, -23168, -22478, -22066, -22263, -23992, -24398, -24821, -26567, -25563, -26156, -25605, -26105, -26391, -25959, -25354, -25366, -26465, -26772, -25812, -25405, -25293, -26805, -29343, -31190, -31647, -32224, -32780, -32636, -32124, -32648, -33977, -34820, -36280, -36874, -35570, -35237, -33215, -34272, -33742, -32777, -32337, -31360, -31185, -31081, -30244, -28997, -27578, -27596, -27393, -27207, -27258, -27371, -26831, -26142, -26505, -26753, -26752, -26340, -26319, -26206, -26212, -26476, -26642, -26790, -26789, -26490
};
INT32 LON[156]{ 73025, 73056, 72348, 71368, 70694, 70816, 69896, 69756, 68782, 67560, 66618, 66209, 66586, 66171, 65126, 63698, 62961, 62424, 62597, 63580, 64129, 64918, 66398, 67329, 67455, 68054, 70343, 72531, 74184, 76406, 78643, 80838, 83212, 84528, 86157, 87738, 88750, 89554, 90109, 90485, 90798, 91481, 90374, 88523, 86799, 84249, 83107, 81232, 80334, 78805, 77591, 76457, 75045, 73544, 72271, 71062, 69696, 68603, 67876, 67306, 66004, 64291, 62692, 61926, 61540, 61192, 61142, 61042, 61153, 61206, 60941, 60356, 59374, 58525, 57722, 57662, 56746, 55771, 55351, 54571, 54200, 54324, 53027, 51690, 50442, 49689, 48362, 46033, 41235, 41275, 41375, 40487, 39458, 38626, 39822, 40245, 40429, 40149, 39217, 38947, 39100, 36916, 38485, 36234, 38713, 40824, 41513, 41779, 41089, 40006, 38967, 38710, 36581, 36241, 35660, 34026, 34544, 32490, 31168, 30185, 29004, 26684, 23031, 15876, 15791, 15628, 13732, 12223, 11979, 12393, 12141, 11593, 10385, 8649, 8551, 9156, 7629, 6108, 6080, 5060, 4762, 4922, 4524, 3795, 3522, 3814, 3792, 2947, 2949, 2763, 2349, 2648, 2273, 1383, 775, 245
};
//POINT apt[156]{};
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8)[*(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4)];
for (int i = 0; i < 156; i++) // Naplníme pole pro vynášení bójí
{
apt[i].x = (float)LON[i] / (float)180000 * 960 + 960;
apt[i].y = (float)abs(LAT[i]) / (float)90000 * 540 + 540;
}
Těch 156 hodnot mám v C++ jen pro účely testování. Pokud program při ladění zastavím za blokem řádků výše a najedu kurozorem na řádek s POINT na apt (address of points structure) zobrazí se mi:
apt|0x0000000000000000 <NULL>
Pokud odzávorkuji řádek //POINT apt[156]{}; a z řádku níže udělám komentář je vše v pořádku:
apt|0x00000093a04fe960 {{x=1349 y=600}, {x=1349 y=601}, {x=1345 y=606}, {x=1340 y=606}, {x=1337 y=604}, ...}
Když ti to vrací nulu, tak proto, že tam prostě je. Mně to pořád připadá, že se pokoušíš definovat to pole s velikostí jako
body[pocet]
Tak ti znova píšu, že tam ta velikost nebude! Takhle je to čtení z pole bajtů (bsrc). A zjevně je tam nulička.
Milan ti to napsal, tak to použij a neřeš, že ti nefunguje úplně jiný kód, kterému nerozumíš, ale zuby nehty ho tam držíš.
#18 gna
Nějak se motáme v kruhu. Myslím, že jsem zcela jasně popsal, o co mi jde. Strukturu POINT potřebuji nastavit na má data v paměti a to včetně jejich počtu. Nejde jen úpravu souřadnic pro jejich vynesení do Full HD okna (1980 x 1080 bodů). Správné nastavení na data v paměti potřebuji pro jejich vykreslení pomocí funkce Polyline, která použivá parametr apt. Když na něj při ladění programu najedu, ukazuje počet bodů 156...
#19 Kevil
podle mě nechápeš rozdíl v definici "pole" - "ukazatel na pole" v tom je dost rozdíl
další věc je typování máš data jako dword, ale point jsou double v podstatě bys to měl přetypovat do nového pole
třetí věc co se chci zeptat už 2dny, kde jsi vzal ten offset 0x01719F0F6B - to ti tam podle mě může dělat neplechu, alokace je dynamická může se pokaždé v paměti nacházet jinde, pokud máš 64bit kompilátor a používáš 64bit pointery, tak to nepotřebuješ - ten pointer si udělej globální šoupni do něj ten ukazatel na alokovanou paměť a nijak dál ho zpracovávat nemusíš - v podstatě mi to připadá, že ukazuješ na konec dat tzn. někam kde už data nejsou
statické pole POINT apt[X] obsahuje
1) pointer na začátek alokované paměti pro daný typ (sizeof POINT * X)
2) velikost = X
ukazatel POINT *apt ukazuje v podstatě na místo v paměti , počet prvků si musíš držet sám v jiné proměnné, typ point určuje pouze chování a práci s apt, např apt++ posune ukazatel o sizeof(POINT) na další bod
jinak práce s apt jako pointerem by měla myslím vypadat trošku jinak:
hodnota = *apt.x;
*apt.y = hodnota;
#23 Kevil
programy obvykle pracují tak, že na proměnné mají zásobník, co se týče pak objektů, stringů a polí tak, na zásobníku mají referenci (odkaz na objekt/pole kdesi jinde v paměti), kde pak jsou vlastní data včetně velikosti.
ukazatel ale funguje jinak ten prostě ukazuje někam do paměti a o zbytek se musíš postarat ty, teoreticky by ještě šlo použít dvojitý pointer ukazatel na ukazatel, ale pak bys musel před data pole vložit tu délku a do reference vložit tu adresu dat.
Offset 0x01719F0F6B ? To je jednoduché. Pomocí VirtualAlloc alokuji 7 GB paměti do které načtu 6 GB soubor (to je těch 0x01719F0F6B), data pak ukládám za něj do zbylého 1 GB RAM.
nj, ale tam žádná data načtená nejsou, tak ti to nemůže nic vracet žádný počet vbojí, žádná ID nebo počty bodů a už vůbec ne data bodů.
jinak zkoušel jsem to v online compileru jestli to přetypování funguje a mělo by to fungovat
// Example program
#include <iostream>
#include <string>
class Point
{
public:
float X, Y;
};
int main()
{
float test[6]{128.20,10.28,15.11,200.0,0.15,30.5};
Point *apt = (Point *) &test[0];
for (int i=0;i<3;i++)
{
std::cout << "BOD " << i << " X=" << apt[i].X << " Y=" << apt[i].Y << std::endl;
}
return 0;
}
//výsledek
BOD 0 X=128.2 Y=10.28
BOD 1 X=15.11 Y=200
BOD 2 X=0.15 Y=30.5
#23 Kevil
já bych se s tím nepáral, pokud potřebuješ přepočítat ty dwordy na float/double souřadnic, tak na soubor si alokuj jen těch 6GB, žádný rezervní 1GB prostě jen na soubor,
poté si vytáhni počet bodů boje a alokuj si Point pole podle toho počtu bodů a následně do toho převeď data bóje
#17 Kevil
Těch 156 hodnot mám v C++ jen pro účely testování. Pokud program při ladění zastavím za blokem řádků výše a najedu kurozorem na řádek s POINT na apt (address of points structure) zobrazí se mi:
apt|0x0000000000000000 <NULL>
zkus si tam za tu řádku s
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8);
vyplnit apt[0].x a y a pak při breaku na to kouknout
#24 MilanL
nj, ale tam žádná data načtená nejsou, tak ti to nemůže nic vracet žádný počet vbojí, žádná ID nebo počty bodů a už vůbec ne data bodů
Data tam samozřejmě jsou, ukládá mi je tam ASM funkce a při breaku C++, výpis RAM paměti, je tam spolehlivě vidím. Díky za ukázku v C++ která ale nevystihuje podstatu věci tj. přístup na data ze skutečné RAM paměti. V programu by jsi musel použít VirtualAlloc, do paměti si zapsat nějaké hodnoty a pak ty hodnoty použít v POINT class.
#26 MilanL
Dal jsem tam:
apt[0].x = -10127;
apt[0].y = 73025;
to funguje. Nehlásí to žádnou chybu, data se správně uloží a apt odkazuje na správnou adresu paměti tj. na ty první dvě hodnoty. Viz screen shot obrazovky. Na adrese 0x000002360c3c0fb3 jsou správně uloženy obě hodnoty (DWORD) x= -10127 tj. 71 D8 FF FF a y=73025 tj. 41 1D 01 00. Teď ještě do apt nějak dostat počet bodů.
#28 Kevil
no vidíš takže to funguje, počet bodů musíš mít někde zvlášť i do té funkce Polyline vstupuje počet samostatně, tzn někam by ho ta ASM funkce měla uložit, případně by sis to musel zjistit procházením paměti dokud nenarazíš na nějaké zakončení dat.
EDIT: jinak já v C++ normálně ve větším neprogramuju.
#29 MilanL
jinak tomu odpovídá ten kod co jsem napsal ve #14, jen ten počet boji není v paměti, ale v proměný X co se vrací z té hledací funkce, drobnost ten výpis ID bojí má být od adresa+4 ? tam je něco v paměti na těch prvních 4 BYTEch?
#29 MilanL
tak a ted koukni co ti apk ukazuje, když uděláš jen 1 krok za to přiřazení pointeru, ještě než nastavíš tu [0].x, adresu už ti to dělá správně, pokud by to neukazovalo čísla x y může být problém s formátem čísel v paměti mezi ASM a C++., a ten výpis paměti by se hodil pár řádek hned od té adresy pracovní paměti tzn.(bsrc + offset)
Jaj to je ale kod. Jedna magicka konstanta vedle druhy a nejaky zahadny "bsrc".
Na 7GB soubor bych vyuzil mapovani souboru do pameti. Pokud je to jeste nahodou binarni soubor, tak uz se nemusis ani obtezovat s parsovanim.
Na co vubec ten asm potrebujes? Podle toho, jak se v tom placas, to urcite nemuzes v asm napsat rychleji, nez na to pouzit proste C++. Rozjel bych to prvni normalne, a az kdyz zmeris, ze je to moc pomale, tak zkousek saskovat s optimalizaci.
#32 KIIV
Nejsem žádný programátor, to jsem se v C++ potřeboval, jsem se z příkladů naučil za měsíc. Pokud by bylo možné vynést křivky rovnou z ASM udělal bych to (zavolat z ASM funkci Polyline v C++). Oproti C++ nemám s assemblerem žádný problém. Zkus v C++ hledat v 50 milionech řádcích ;-). Mapování souboru mi nepomůže, pokud načtu celý soubor do paměti, rychleji s ním pracovat nelze.
#30 MilanL
tam je něco v paměti na těch prvních 4 BYTEch?
Ano, to X je počet nalezených bóji DWORD, které se pohybovaly mezi dvěma zadanými oblastmi (ve tvaru čtverce). Dosud jsem postupoval tak, že mi program našel počet bójí a čísla bóji. Ta jsem pak zadal do dotazu PowerQuery v Excelu, ke kterému jsem měl externě připojený ten velký soubor. Výsledkem byly souřadnici bodů dané bóje v Excelu. Excelový soubor se souřadnicemi jsem pak pomocí https://www.earthpoint.us/ExcelToKml.aspx převedl na KML soubor a vynesl na Google Earth. V neplacené verzi je tam ale omezení jen na 200 bodů, počet bodů musím proti poměrně snížit. Bóje ale mohou obsahovat klidně 5 000 bodů. Výsledekm je pak např. takováto mapa.
#34 Kevil
hele Polyline vůbec nepotřebuje vědět jak je pole velký jemu stačí adresa začátku a počet bodů k vykreslení, můžeš mít pole point třeba 10000 bodů, hodit mu adresu vybranýho bodu a počet a on ti zobrazí ten úsek. takže ty potřebuješ ten počet bodů hlavně kvůli tomu abys rozlišil, kde začínají data jednotlivých bojí a to určíš podle předchozí boje Adresa + počet * sizeof(Point)
#35 MilanL
no vidím drobnou vadu na kráse - jak řešíš když boje oblast opustí a zas se jinudy vrátí tam by mělo být přerušení,
jinak podle úrovně optimalizace kompilace C++ si proti němu assemblerem až tolik nepomůžeš, jednou z fází compilace je převod do asm, jen jde o to jak kompiler využije možností procesoru (využití registrů a instrukčních sad)
C/c++ není excel, kde je interpretovanej VB
jinak lze provést redukci bodů k zobrazení v závislosti na přesnosti, když je více bodů v přímce nebo s minimální odchylkou - dle požadované přesnosti, můžeš mezibody vynechat.
//nastavení pro vykreslování if (x>0) { DWORD IDcka[x+1]; //pole pro ID, X+1 pro jednotné indexování DWORD Pocet[x+1]; //pole pro počty bodů bójí Point *apt[x+1]; //pole pro adresy začátků bodů jednotlivých bójí DWORD *TMP= (Point *)(bsrc + 0x01719F0F6B + x * 8 + 4); //adresa bodů 1. bóje for (int i =1; i<=(int)x; i++) { IDcka[i] = *(DWORD *)(bsrc + 0x01719F0F6B + 4 * i);printf("%i\n", IDcka[i]);Pocet[i] = *(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4 * i); apt[i] = TMP; TMP += Pocet[i]; //začátek pro další boji, nejsem si jist zda tam nemá být ještě +1 }// VYKRESLOVÁNÍGraphics graphics(hdc); for (int i =1; i<=(int)x; i++) { // nastavit barvu pro vykreslování bud z pole podle i nebo podle ID bóje Polyline(hdc,apt[i],Pocet[i]); } } // konec podmínky X>0
EDIT: oprava u cyklů podmínka ukončení chybělo "=" v i<=(int)x
v podstatě by to šlo provést vše v 1 cyklu
#38 KIIV
von to má komplet natažený do RAM.
#34 Kevil
Kevile, ještě bych ten ofset dal do proměnné, když tam vložíš velikost dat ze souboru, pak to můžeš použít na různě velké soubory případně to rovnou spojit s tou bázovou adresou třeba
DWORD *work1G = (DWORD *)(bsrc + 0x01719F0F6B); nebo
DWORD *work1G = (DWORD *)(bsrc + filesize);
#41 Kevil
vyzkoušej nejdřív ten první cyklus jestli ti to správně vyhodí ty IDčka a počty
pak se můžeš kouknout na adresy jestli to udělá správně ty posuny začátků,.kdyby ti druhá boje začínala tam kde končí první je třeba přidat tu +1, ukazatele jsou definovaný jako point takže to += je automaticky braný (přičítaná hodnota * sizeof(point))
#42 MilanL
no grafika je dnes v asm náročnější než za dob EGA VESA DOSu, kdy se dalo pracovat přímo s adaptérem, dnes tě k němu OS jen tak nepustí.
Pokud to máš takhle zkombinovaný c++ + asm, neměl by být takový problém volat Cčkovou proceduru z asm, stačí správně předat parametry (v registrech nebo na zásobníku) a zavolat funkci
call polyline
#41 Kevil
Teoreticke a neuplne dotazy bez moznosti cokoliv otestovat znamenaji teoreticke ci obecne odpovedi. Kdyby tu bylo neco, co se da zkompilovat a vyzkouset, tak se da i hledat reseni. Nemam cas na to generovat 6GB Textak a programovat to vsechno od nuly. Proc myslis, ze uz je tu 44 prispevku a zadna poradna rada.
S mapovanim souboru do pameti uz sem delal na linuxu a je to setsakra rychlejsi nez nacitani ze souboru po znacich. Jde o to, ze ty k tomu pristupujes jako k poli a vubec te nezajima cele nacitani, to resi operacni system.
#44 KIIV
o soubor vubec nejde, jde o parametry pro proceduru POLYLINE, assembler mu vygeneruje někam do paměti pole bodů a nevěděl jak to nastavit do point proměnný, výchozí adresa je jasná
POINT *apt = adresa paměti s body
ale furt k tomu apt chtěl cpát velikost pole, tak jsem mu vysvětloval, že to polyline nechce, že tam ten počet bodů vstupuje samostatně, tak mu ten počet musí bud vrátit ta asm funkce nebo si to musí nějak zjistit projetím té paměti.
v podstatě může mít 1000 bodů poslat do Polyline adresu 50 bodu a počet 200 a vykreslí mu to tu část 50, až 250. bod.
#37 MilanL
Stále bohužel nefunguje správné přiřazení bodů v paměti do apt.
POINT apt[156];
takto to funguje správně. Tj. když v breaku najedu na apt, zobrazí se okno s adresou apt a následně 156 párů bodů x, y
Pokud ale použiju kód
bodu = *(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4);
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8)[bodu];
for (int i = 0; i < bodu; i++) // Naplníme pole pro vynášení bójí
{
if (apt[i].x > 180000)
{
apt[i].x = 960 - ((-1)*apt[i].x - 180000) / (float)180000 * 960;
}
else {
apt[i].x = (float)apt[i].x / (float)180000 * 960 + 960;
}
if (apt[i].y > 90000)
{
apt[i].y = 540 - ((-1)*apt[i].y - 90000) / (float)90000 * 540;
}
else {
apt[i].y = (float)apt[i].y / (float)90000 * 540 + 540;
}
}
POINT je špatně nastaven a data se zapisují mimo správnou paměť
I když z řádku vyhodím [body]. tj. počet bodů, nepřiřadí se 2 315 bodů správně a Polyline nic nevykreslí
Jestli to má takovou strukturu
DWORD pocet_boji;
DWORD idecka[pocet_boji];
DWORD pocty[pocet_boji];
POINT body[...];
Tak takhle dostaneš ukazatele na všechno
DWORD *pPocetBoji = (DWORD*) (zacatek);
DWORD *pIdecka = pPocetBoji + 1;
DWORD *pPocty = pIdecka + *pPocetBoji;
POINT *pBody = (POINT*) (pPocty + *pPocetBoji);
A projdeš si to jak potřebuješ.
POINT *apt = pBody;
for (DWORD i = 0; i < *pPocetBoji; i++)
{
DWORD idecko = pIdecka[i]
DWORD pocet = pPocty[i];
PolyLine(hdc, apt, pocet);
apt += pocet;
}
Hotovo. Máš to tady už několikrát.
#46 Kevil
zas tam k *apt cpeš tu velikost ta tam prostě nemá co dělat !!!!!
To vím i já kterej v C++ skoro nedělám
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8)[bodu];
#49 gna
jj to je to co jsem mu posílal včera přes vyčtení hodnot, ty to děláš s ukazateli.
problém je v tom, že tam furt cpe k *apt tu velikost.
#50 MilanL
Pánové, musí se na to úplně jinak. Dostal jsem radu:
As input, Polyline() takes a pointer to an array of POINTstructs, and the number of elements in the array.
POINT has two data members that are both of type LONG, so if you have an existing array of DWORD pairs in memory, you could simply type-cast that address to a POINT* pointer when you pass it to Polyline() (as DWORD and LONG have the same byte size in the Win32 API), eg:
DWORD *pairs = ...;
DWORD numPairs = ...;
...
Polyline(hdc, reinterpret_cast<POINT*>(pairs), numPairs);
However, a safer approach is to simply allocate a separate POINT[] array in memory and copy the DWORD values into it, then pass that array to Polyline(), eg:
DWORD *pairs = ...;
DWORD numPairs = ...;
...
POINT *points = new POINT[numPairs];
for(DWORD i = 0; i < numPairs; ++i)
{
points[i].x = pairs[i*2];
points[i].y = pairs[(i*2)+1];
}
Polyline(hdc,
FYI, in your question you mention GDI+, but Polyline() is part of GDI, not GDI+. The GDI+ equivilent is Graphics::DrawLines(), but it requires an array of Pointclass objects instead of POINT structs. You can't safely type-cast a DWORD array to Point*, you would have to actually construct the individual Point objects (using the Point(int,int) constructor), similar to above, eg:
DWORD *pairs = ...;
DWORD numPairs = ...;
...
Point *points = new Point[numPairs];
for(DWORD i = 0; i < numPairs; ++i)
points[i] = Point(static_cast<INT>(pairs[i*2]), static_cast<INT>(pairs[(i*2)+1]));
Graphics *g = Graphics::FromHDC(hdc);
Pen pen(...);
g->DrawLines(&pen, points, numPairs);
delete g;
delete[] points;
Pomocí reinterpret_cast mi příkaz Polyline už začal něco kreslit, zatím blbě, musím zkontrolovat přepočet na správné pozice.
#51 Kevil
to je, ale jiný problém,
Ty jsi měl problém s tím odkazem na pole, že jsi tam cpal za adresu ty hranatý závorky s velikostí a ta adresa apt pak byla nesmyslná. V tvé odpovědi #28 Ti to do té paměti ukazovalo správně, nevím, proč ses pak vrátil k tomu nesmyslu Point *apt=(adresa)[počet];
Formátování dat je druhý problém - byl předpoklad, že data bodů v paměti jsou float, pokud ne je třeba je před použitím Polyline převést.
tzn. zjistit počet bodů, nastavit si pointer na data , vytvořit statické pole Point dle počtu bodů a do něj zkonvertovat data. ale o tom jsem též psal výše odpověď #25.
hlavička funkce polyline
BOOL Polyline( HDC hdc, CONST POINT *apt, int cpt );
jak je vidět, do funkce druhým argumentem vstupuje Point pole jako ukazatel do paměti na data typu Point, tzn. funkce nemá přístup k velikosti, ta se tam posílá tím třetím argumentem, navíc neposílá se velikost pole, ale počet bodů typu POINT, které chceš vykreslit.
dalším úskalím může být měřítko pozice bodů vs. rozlišení obrazovky.ve 2D bys tam neměl mít záporné hodnoty, bod 0.0 je v levém horním rohu tzn. je třeba zajistit případný posun bodu 0,0 na střed obrazovky
#46 Kevil
doplněk/oprava k tvé #46 tak jak jsi to měl
apt[i].x = 960 - ((-1)*apt[i].x - 180000) / (float)180000 * 960;
nemohla ta konverze fungovat na apt[i] na pravé straně bere word z paměti jako float. takže špatný formát čísla, původní hodnotu si musíš načíst jako DWORD
bodu = *(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4);
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8);
DWORD *src = (DWORD*)(bsrc + 0x01719F0F6B + 8 * x + 8);
for (int i = 0; i < bodu; i++) // Naplníme pole pro vynášení bójí
{
if (src[2*i] > 180000)
{
apt[i].x = 960 - ((-1)*(float)src[2*i] - 180000) / (float)180000 * 960;
}
else {
apt[i].x = (float)src[2*i] / (float)180000 * 960 + 960;
}
if (src[2*i+1] > 90000)
{
apt[i].y = 540 - ((-1)*(float)src[2*i+1] - 90000) / (float)90000 * 540;
}
else {
apt[i].y = (float)src[2*i+1] / (float)90000 * 540 + 540;
}
}já když něco nefunguje, zkouším jít po menších kouskách třeba i simulovaně, např, pro srovnání dat mezi dword a point bych naplnil první 2 hodnoty pomocí *dword a pak kouknul co mi na tom místě ukáže *Point
Zkouška ověření formátu v paměti - použit online Kompilátor nemám tu VS.
// Example program
#include <iostream>
#include <string>
typedef unsigned int DWORD;
class Point
{
public:
float X, Y;
};
int main()
{
DWORD test[6]{10,30,43330,12222222,33,400};
DWORD *src = &test[0];
Point *apt = (Point *) &test[0];
std::cout << sizeof(DWORD) << std::endl;
for (int i=0;i<3;i++)
{
std::cout << "DWORD " << src[2*i] << " , " << src[2*i+1];
std::cout << " >> POINT " << i << " X=" << apt[i].X << " Y=" << apt[i].Y << std::endl;
}
return 0;
}
/*
4 - ověření size po typedef na test byl použit online compilátor
DWORD 10 , 30 >> POINT 0 X=1.4013e-44 Y=4.2039e-44
DWORD 43330 , 12222222 >> POINT 1 X=6.07183e-41 Y=1.7127e-38
DWORD 33 , 400 >> POINT 2 X=4.62428e-44 Y=5.60519e-43
*/
DWORD bodu = *(DWORD *)(bsrc + 0x01719F0F6B + 4 * x + 4);
POINT *apt = (POINT*)(bsrc + 0x01719F0F6B + 8 * x + 8); - není to +8 chyba nemá tam být taky jen +4 ?
+4 vynechává ten první DWORD kde by měl být počet bojí, ale +8 ti vynechá další dword za počty bodů pokud tam opravdu nemášvynechaný další zarovnávací dword, tak ty body budeš mít v posunu Point[0].x bude ve skutečnosti Point[0].y a Point[0].y bude Point[1].x
Proto při programování používám malé pracovní vzorky u kterých vím v každém okamžiku jaká hodnota má kde být.
#57 MilanL
Reálně potřebuji vyřešit ale tohle:
// Test.cpp : Zkouška přiřazení dvojic hodnot v paměti do třídy POINT
//
#include "stdafx.h"
#include <stdlib.h>
int main()
{
void *memory = calloc(12, sizeof(int)); //Alokujeme pole pro 6 INT párů po 4 bytech
int *ptr = (int *)memory;
for (int i = 0; i < 12; i++)
{
*ptr = 7; // Nevím jak tam zadata, aby se ukládala proměnná "i"
printf("%i\n", *ptr);
ptr++; // Posun na začátek dalšího DWORD
}
// Tady by pak mělo být přiřazení uložených hodnot v paměti do třídy POINT (asi včetně počtu dvoji bodů tj. 6)
free(memory);
return 0;
}*ptr = 7; // Nevím jak tam zadata, aby se ukládala proměnná "i"
Težko říct, co tím myslíš.
*ptr = i;
// Tady by pak mělo být přiřazení uložených hodnot v paměti do třídy POINT (asi včetně počtu dvoji bodů tj. 6)
http://programujte.com/forum/vlakno/192557-jak-odkazat-na-tridu-point-do-pameti/#p381193
Tak už mi vykreslování pomocí Polyline chodí :-). Zádrhel byl v tom, že jsem chybně přepočítával souřadnice bodů na body na obrazovce a ještě jsem měl uloženo nejdříve Y a pak X ... Odkaz na body v paměti
reinterpret_cast<POINT*>(memory)
funguje v pohodě.
Body pak nenavazovaly na sebe a funkce Polyline to nemohla vykreslit. Díky všem za rady ;-).
#64 Kevil
nebyla ta záměna X Y způsobena tím posunem ukazatele +8 místo +4? jinak vykreslování by neměl být problém ani při prohození souřadnic jen bys měl obrázek otočenej o 90°.
Ale stejně pozor na ten výskyt boje v oblasti v případě, že boje oblast opustí a po čase se tam vrátí, v podstatě by to z toho hledání mělo vyjít jako data pro 2 boje se stejným ID, ale v každém časovém úseku samostatné body trasy.
Zjistit počet nových příspěvků
Ano, opravdu chci reagovat → zobrazí formulář pro přidání příspěvku
© 2003–2024 Programujte.com