static int amd_flash_write_cfibuffer(struct flash_info *info, unsigned long dest,
const u8 *cp, int len)
{
flash_sect_t sector;
int cnt;
void *src = (void *)cp;
void *dst = (void *)dest;
cfiword_t cword;
sector = find_sector (info, dest);
flash_unlock_seq(info);
flash_make_cmd (info, AMD_CMD_WRITE_TO_BUFFER, &cword);
flash_write_word(info, cword, (void *)dest);
if (bankwidth_is_1(info)) {
cnt = len;
flash_write_cmd(info, sector, 0, (u32)cnt - 1);
while (cnt-- > 0) {
flash_write8(flash_read8(src), dst);
src += 1, dst += 1;
}
} else if (bankwidth_is_2(info)) {
cnt = len >> 1;
flash_write_cmd(info, sector, 0, (u32)cnt - 1);
while (cnt-- > 0) {
flash_write16(flash_read16(src), dst);
src += 2, dst += 2;
}
} else if (bankwidth_is_4(info)) {
static int amd_flash_write_cfibuffer (struct flash_info *info, ulong dest, const uchar * cp,
int len)
{
flash_sect_t sector;
int cnt;
int retcode;
volatile cfiptr_t src;
volatile cfiptr_t dst;
cfiword_t cword;
src.cp = (uchar *)cp;
dst.cp = (uchar *) dest;
sector = find_sector (info, dest);
flash_unlock_seq(info);
flash_make_cmd (info, AMD_CMD_WRITE_TO_BUFFER, &cword);
flash_write_word(info, cword, (void *)dest);
if (bankwidth_is_1(info)) {
cnt = len;
flash_write_cmd (info, sector, 0, (uchar) cnt - 1);
while (cnt-- > 0) *dst.cp++ = *src.cp++;
} else if (bankwidth_is_2(info)) {
cnt = len >> 1;
flash_write_cmd (info, sector, 0, (uchar) cnt - 1);
while (cnt-- > 0) *dst.wp++ = *src.wp++;
} else if (bankwidth_is_4(info)) {
int main()
{
int exit = 0;
MAP* map = load_map("zaza.wad");
init();
clock_t last_clock = clock();
while(!exit)
{
clock_t now = clock();
float dt = (float)(now - last_clock) / CLOCKS_PER_SEC;
last_clock = now;
VEC2F view_dir = vec2f(cos(ang), sin(ang));
VEC2F view_dir_norm = vec2f(-view_dir.y, view_dir.x);
if(key[KEY_ESC]) exit = 1;
if(key[KEY_S]) vp = vec2f_sum(vp, vec2f_uscale(view_dir, -move_speed * dt));
if(key[KEY_W]) vp = vec2f_sum(vp, vec2f_uscale(view_dir, move_speed * dt));
if(key[KEY_A]) vp = vec2f_sum(vp, vec2f_uscale(view_dir_norm, -move_speed * dt));
if(key[KEY_D]) vp = vec2f_sum(vp, vec2f_uscale(view_dir_norm, move_speed * dt));
if(key[KEY_LEFT]) ang -= rot_speed * dt;
if(key[KEY_RIGHT]) ang += rot_speed * dt;
clear_to_color(buffer, makecol(64, 64, 64));
SECTOR* s = find_sector(map, map->node_num - 1, vp);
float h = s->floor_height + 45;
int i = 0;
for(i = 0; i < H_RES; ++i)
{
float t = i - H_RES / 2;
float u = FOCAL_DIST;
VEC2F ray_dir = vec2f_sum(vec2f_uscale(view_dir, u), vec2f_uscale(view_dir_norm, t)); //vec2f(view_dir.x * FOCAL_DIST + view_dir_norm.x * t, view_dir.y * FOCAL_DIST + view_dir_norm.y * t);
float ray_len = sqrt(ray_dir.x * ray_dir.x + ray_dir.y * ray_dir.y);
ray_dir.x /= ray_len;
ray_dir.y /= ray_len;
int minh = 0;
int maxh = SCREEN_H;
render_col(buffer, map, map->node_num - 1, vp, -h, ray_dir, i, &minh, &maxh);
printf("\n");
//line(buffer, SCREEN_W / 2, SCREEN_H / 2, SCREEN_W / 2 + ray_dir.x * 200, SCREEN_H / 2 + ray_dir.y * 200, makecol(255, 255, 255));
}
draw_sprite(buffer, mouse_sprite, mouse_x, mouse_y);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
}
destroy_map(map);
deinit();
return 0;
}END_OF_MAIN()
static int flash_write_cfibuffer(flash_info_t * info, ulong dest, uchar * cp,
int len)
{
int sector;
int cnt;
int retcode;
volatile cfiptr_t src;
volatile cfiptr_t dst;
src.cp = cp;
dst.cp = (uchar *) dest;
sector = find_sector(info, dest);
flash_write_cmd(info, sector, 0, FLASH_CMD_CLEAR_STATUS);
flash_write_cmd(info, sector, 0, FLASH_CMD_WRITE_TO_BUFFER);
if ((retcode = flash_status_check(info, sector, info->buffer_write_tout,
"write to buffer")) == ERR_OK) {
switch (info->portwidth) {
case FLASH_CFI_8BIT:
cnt = len;
break;
case FLASH_CFI_16BIT:
cnt = len >> 1;
break;
case FLASH_CFI_32BIT:
cnt = len >> 2;
break;
default:
return ERR_INVAL;
break;
}
flash_write_cmd(info, sector, 0, (uchar) cnt - 1);
while (cnt-- > 0) {
switch (info->portwidth) {
case FLASH_CFI_8BIT:
*dst.cp++ = *src.cp++;
break;
case FLASH_CFI_16BIT:
*dst.wp++ = *src.wp++;
break;
case FLASH_CFI_32BIT:
*dst.lp++ = *src.lp++;
break;
default:
return ERR_INVAL;
break;
}
}
flash_write_cmd(info, sector, 0,
FLASH_CMD_WRITE_BUFFER_CONFIRM);
retcode =
flash_full_status_check(info, sector,
info->buffer_write_tout,
"buffer write");
}
flash_write_cmd(info, sector, 0, FLASH_CMD_CLEAR_STATUS);
return retcode;
}
inline void cmd_read(void)
{
t_sector *sector;
loop:
sector = find_sector(&FDC.command[CMD_C]); // locate the requested sector on the current track
if (sector) { // sector found
FDC.result[RES_ST1] = sector->flags[0] & 0x25; // copy ST1 to result, ignoring unused bits
FDC.result[RES_ST2] = sector->flags[1] & 0x61; // copy ST2 to result, ignoring unused bits
if (FDC.command[CMD_CODE] == 0x4c) { // read deleted data command?
FDC.result[RES_ST2] ^= 0x40; // invert Control Mark
}
if ((FDC.flags & SKIP_flag) && (FDC.result[RES_ST2] &= 0x40)) { // skip sector?
if (FDC.command[CMD_R] != FDC.command[CMD_EOT]) { // continue looking?
FDC.command[CMD_R]++; // advance to next sector
goto loop;
}
else { // no data to transfer -> no execution phase
LOAD_RESULT_WITH_STATUS
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
else { // sector data is to be transferred
int sector_size;
if (FDC.result[RES_ST2] &= 0x40) { // does the sector have an AM opposite of what we want?
FDC.command[CMD_EOT] = FDC.command[CMD_R]; // execution ends on this sector
}
if (FDC.command[CMD_N] == 0) { // use DTL for length?
sector_size = FDC.command[CMD_DTL]; // size of sector is defined by DTL value
if (sector_size > 0x80) {
sector_size = 0x80; // max DTL value is 128
}
}
else {
sector_size = 128 << FDC.command[CMD_N]; // determine number of bytes from N value
}
FDC.buffer_count = sector_size; // init number of bytes to transfer
FDC.buffer_ptr = sector->data; // pointer to sector data
FDC.buffer_endptr = active_track->data + active_track->size; // pointer beyond end of track data
FDC.timeout = INITIAL_TIMEOUT;
read_status_delay = 1;
}
}
else { // sector not found
FDC.result[RES_ST0] |= 0x40; // AT
FDC.result[RES_ST1] |= 0x04; // No Data
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
SECTOR* find_sector(MAP* map, int idx, VEC2F vp)
{
if(idx & SHORT_SIGN_FLAG)
{
SSECTOR* ssector = &map->ssectors[(short)(idx & ~SHORT_SIGN_FLAG)];
SEG* seg = &map->segs[ssector->first_seg_idx];
LINEDEF* linedef = &map->linedefs[seg->linedef_idx];
SIDEDEF* sidedef = seg->dir ? &map->sidedefs[linedef->neg_sidedef_idx] : &map->sidedefs[linedef->pos_sidedef_idx];
return &map->sectors[sidedef->sector_idx];
}
else
{
NODE* node = &map->nodes[idx];
VEC2F n = vec2f(-node->y2, node->x2);
if(vec2f_dot(n, vec2f(vp.x - node->x1, vp.y - node->y1)) >= 0)
return find_sector(map, node->right_child_idx, vp);
else
return find_sector(map, node->left_child_idx, vp);
}
return NULL;
}
inline void cmd_scan(void)
{
t_sector *sector;
loop:
sector = find_sector(&FDC.command[CMD_C]); // locate the requested sector on the current track
if (sector) { // sector found
FDC.result[RES_ST1] = sector->flags[0] & 0x25; // copy ST1 to result, ignoring unused bits
FDC.result[RES_ST2] = sector->flags[1] & 0x61; // copy ST2 to result, ignoring unused bits
if ((FDC.flags & SKIP_flag) && (FDC.result[RES_ST2] &= 0x40)) { // skip sector?
if (FDC.command[CMD_R] != FDC.command[CMD_EOT]) { // continue looking?
FDC.command[CMD_R] += FDC.command[CMD_STP]; // advance to next sector
goto loop;
}
else { // no data to transfer -> no execution phase
LOAD_RESULT_WITH_STATUS
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
else { // sector data is to be transferred
int sector_size;
if (FDC.result[RES_ST2] &= 0x40) { // does the sector have an AM opposite of what we want?
FDC.command[CMD_EOT] = FDC.command[CMD_R]; // execution ends on this sector
}
sector_size = 128 << FDC.command[CMD_N]; // determine number of bytes from N value
FDC.buffer_count = sector_size; // init number of bytes to transfer
FDC.buffer_ptr = sector->data; // pointer to sector data
FDC.buffer_endptr = active_track->data + active_track->size; // pointer beyond end of track data
FDC.flags &= ~SCANFAILED_flag; // reset scan failed flag
FDC.result[RES_ST2] |= 0x08; // assume data matches: set Scan Equal Hit
FDC.timeout = INITIAL_TIMEOUT;
read_status_delay = 1;
}
}
else { // sector not found
FDC.result[RES_ST0] |= 0x40; // AT
FDC.result[RES_ST1] |= 0x04; // No Data
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
inline void cmd_write(void)
{
t_sector *sector;
sector = find_sector(&FDC.command[CMD_C]); // locate the requested sector on the current track
if (sector) { // sector found
int sector_size;
sector->flags[0] = 0; // clear ST1 for this sector
if (FDC.command[CMD_CODE] == 0x45) { // write data command?
sector->flags[1] = 0; // clear ST2
}
else { // write deleted data
sector->flags[1] = 0x40; // set Control Mark
}
if (FDC.command[CMD_N] == 0) { // use DTL for length?
sector_size = FDC.command[CMD_DTL]; // size of sector is defined by DTL value
if (sector_size > 0x80) {
sector_size = 0x80; // max DTL value is 128
}
}
else {
sector_size = 128 << FDC.command[CMD_N]; // determine number of bytes from N value
}
FDC.buffer_count = sector_size; // init number of bytes to transfer
FDC.buffer_ptr = sector->data; // pointer to sector data
FDC.buffer_endptr = active_track->data + active_track->size; // pointer beyond end of track data
FDC.timeout = INITIAL_TIMEOUT;
read_status_delay = 1;
}
else { // sector not found
FDC.result[RES_ST0] |= 0x40; // AT
FDC.result[RES_ST1] |= 0x04; // No Data
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
void t_FDC::cmd_read(void)
{
auto emulator = _emulator.lock();
t_sector *sector;
loop:
sector = find_sector(&command[CMD_C]); // locate the requested sector on the current track
emulator->fdcNotifyRead(driveA.current_side, driveA.current_track, sector);
if (sector) { // sector found
result[RES_ST1] = sector->flags[0] & 0x25; // copy ST1 to result, ignoring unused bits
result[RES_ST2] = sector->flags[1] & 0x61; // copy ST2 to result, ignoring unused bits
if (command[CMD_CODE] == 0x4c) { // read deleted data command?
result[RES_ST2] ^= 0x40; // invert Control Mark
}
if ((flags & SKIP_flag) && (result[RES_ST2] &= 0x40)) { // skip sector?
if (command[CMD_R] != command[CMD_EOT]) { // continue looking?
command[CMD_R]++; // advance to next sector
goto loop;
}
else { // no data to transfer -> no execution phase
LOAD_RESULT_WITH_STATUS();
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
}
else { // sector data is to be transferred
int sector_size;
if (result[RES_ST2] &= 0x40) { // does the sector have an AM opposite of what we want?
command[CMD_EOT] = command[CMD_R]; // execution ends on this sector
}
if (command[CMD_N] == 0) { // use DTL for length?
sector_size = command[CMD_DTL]; // size of sector is defined by DTL value
if (sector_size > 0x80) {
sector_size = 0x80; // max DTL value is 128
}
}
else {
sector_size = 128 << command[CMD_N]; // determine number of bytes from N value
}
buffer_count = sector_size; // init number of bytes to transfer
// Handle weak sectors
int versions_count = 1;
if(sector->declared_size != 0)
versions_count = sector->size/sector->declared_size;
int offset;
if(versions_count > 1)
{
static int weak_counter;
weak_counter = (weak_counter+1)%versions_count;
offset = weak_counter;
}
else
offset = 0;
buffer_ptr = sector->data + sector->declared_size*offset; // pointer to sector data
buffer_endptr = active_track->data + active_track->size; // pointer beyond end of track data
timeout = INITIAL_TIMEOUT;
read_status_delay = 1;
}
}
else { // sector not found
result[RES_ST0] |= 0x40; // AT
result[RES_ST1] |= 0x04; // No Data
if (active_track->sectors == 0)
{
// Not formatted track
result[RES_ST1]|=1; // set MA flag
result[RES_ST2]|=1; // set MD flag
}
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
}
int main()
{
int exit = 0;
MAP* map = load_map("e1m1.wad");
VEC2F vp = vec2f(0.f, 0.f);
float ang, move_speed = 200.f, rot_speed = 2.5f;
init();
//VEC2F vn = vec2f(-v.y, v.x);
//VEC2F ray_dir = vec2f();
//short s = -1;
//s &= ~(1 << 15);
//printf("ZOMG = %d\n", s);
clock_t last_clock = clock();
while(!exit)
{
clock_t now = clock();
float dt = (float)(now - last_clock) / CLOCKS_PER_SEC;
last_clock = now;
VEC2F view_dir = vec2f(cos(ang), sin(ang));
VEC2F view_dir_norm = vec2f(-view_dir.y, view_dir.x);
if(key[KEY_ESC]) exit = 1;
if(key[KEY_S]) vp = vec2f_sum(vp, vec2f_uscale(view_dir, -move_speed * dt));
if(key[KEY_W]) vp = vec2f_sum(vp, vec2f_uscale(view_dir, move_speed * dt));
if(key[KEY_A]) vp = vec2f_sum(vp, vec2f_uscale(view_dir_norm, -move_speed * dt));
if(key[KEY_D]) vp = vec2f_sum(vp, vec2f_uscale(view_dir_norm, move_speed * dt));
if(key[KEY_LEFT]) ang -= rot_speed * dt;
if(key[KEY_RIGHT]) ang += rot_speed * dt;
clear_to_color(buffer, 0);
SECTOR* s = find_sector(map, map->node_num - 1, vp);
float h = s->floor_height + 45;
int i;
for(i = 0; i < H_RES; ++i)
{
float t = i - H_RES / 2;
float u = FOCAL_DIST;
VEC2F ray_dir = vec2f_sum(vec2f_uscale(view_dir, u), vec2f_uscale(view_dir_norm, t)); //vec2f(view_dir.x * FOCAL_DIST + view_dir_norm.x * t, view_dir.y * FOCAL_DIST + view_dir_norm.y * t);
float ray_len = sqrt(ray_dir.x * ray_dir.x + ray_dir.y * ray_dir.y);
ray_dir.x /= ray_len;
ray_dir.y /= ray_len;
render_col(buffer, map, map->node_num - 1, vp, -h, ray_dir, i);
//line(buffer, SCREEN_W / 2, SCREEN_H / 2, SCREEN_W / 2 + ray_dir.x * 200, SCREEN_H / 2 + ray_dir.y * 200, makecol(255, 255, 255));
}
if(key[KEY_TAB])
for(i = 0; i < map->seg_num; ++i)
{
VERTEX v1t = map->vertexes[map->segs[i].v1_idx];
VERTEX v2t = map->vertexes[map->segs[i].v2_idx];
VEC2F v1 = vec2f(v1t.x, v1t.y);
VEC2F v2 = vec2f(v2t.x, v2t.y);
VEC2F mid = vec2f((v1.x + v2.x) / 2, (v1.y + v2.y) / 2);
VEC2F n = normalized_normal(vec2f_diff(v2, v1));
float scl = 1.f / 2.f;
line(buffer, v1.x*scl + SCREEN_W / 2,
v1.y*scl + SCREEN_H / 2,
v2.x*scl + SCREEN_W / 2,
v2.y*scl + SCREEN_H / 2, makecol(255, 255, 255));
circlefill(buffer, (int)vp.x*scl + SCREEN_W/2, (int)vp.y*scl +SCREEN_H/2, 3, makecol(255, 255, 255));
line(buffer, SCREEN_W/2+ mid.x*scl,
SCREEN_H/2 + mid.y*scl,
SCREEN_W/2+ (mid.x + n.x * 10)*scl,
SCREEN_H/2+ (mid.y + n.y * 10)*scl, makecol(255, 255, 255));
line(buffer, SCREEN_W/2+vp.x*scl,
SCREEN_H/2+vp.y*scl,
SCREEN_W/2+(vp.x+view_dir.x*100)*scl,
SCREEN_H/2+(vp.y+view_dir.y*100)*scl, makecol(255, 255, 255));
}
//
draw_sprite(buffer, mouse_sprite, mouse_x, mouse_y);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
}
destroy_map(map);
deinit();
return 0;
}END_OF_MAIN()
