1
0
mirror of https://github.com/TomHarte/CLK.git synced 2024-12-11 00:52:13 +00:00
CLK/Machines/Amiga/Blitter.hpp

128 lines
3.2 KiB
C++
Raw Normal View History

2021-07-22 22:43:07 +00:00
//
// Blitter.hpp
// Clock Signal
//
// Created by Thomas Harte on 22/07/2021.
// Copyright © 2021 Thomas Harte. All rights reserved.
//
#pragma once
2021-07-22 22:43:07 +00:00
#include <cstddef>
#include <cstdint>
2022-08-06 18:40:12 +00:00
#include <string>
#include <vector>
2021-07-22 22:43:07 +00:00
#include "../../ClockReceiver/ClockReceiver.hpp"
2022-08-19 20:38:15 +00:00
#include "BlitterSequencer.hpp"
#include "DMADevice.hpp"
2021-07-22 22:43:07 +00:00
namespace Amiga {
/*!
If @c record_bus is @c true then all bus interactions will be recorded
and can subsequently be retrieved. This is included for testing purposes.
*/
template <bool record_bus = false> class Blitter: public DMADevice<4, 4> {
2021-07-22 22:43:07 +00:00
public:
using DMADevice::DMADevice;
2021-07-22 22:43:07 +00:00
2022-08-19 20:38:15 +00:00
template <int id, int shift> void set_pointer(uint16_t value) {
DMADevice<4, 4>::set_pointer<id, shift>(value);
}
2021-07-22 22:43:07 +00:00
// Various setters; it's assumed that address decoding is handled externally.
//
// In all cases where a channel is identified numerically, it's taken that
// 0 = A, 1 = B, 2 = C, 3 = D.
void set_control(int index, uint16_t value);
void set_first_word_mask(uint16_t value);
void set_last_word_mask(uint16_t value);
2021-07-22 22:43:07 +00:00
void set_size(uint16_t value);
void set_minterms(uint16_t value);
// void set_vertical_size(uint16_t value);
// void set_horizontal_size(uint16_t value);
2021-07-22 22:43:07 +00:00
void set_data(int channel, uint16_t value);
uint16_t get_status();
template <bool complete_immediately> bool advance_dma();
2021-07-22 22:43:07 +00:00
struct Transaction {
enum class Type {
SkippedSlot,
ReadA,
ReadB,
ReadC,
AddToPipeline,
WriteFromPipeline
2022-08-06 18:40:12 +00:00
} type = Type::SkippedSlot;
uint32_t address = 0;
uint16_t value = 0;
2024-02-17 02:47:23 +00:00
Transaction() = default;
Transaction(Type type) : type(type) {}
Transaction(Type type, uint32_t address, uint16_t value) : type(type), address(address), value(value) {}
2022-08-06 18:40:12 +00:00
std::string to_string() const {
std::string result;
switch(type) {
case Type::SkippedSlot: result = "SkippedSlot"; break;
case Type::ReadA: result = "ReadA"; break;
case Type::ReadB: result = "ReadB"; break;
case Type::ReadC: result = "ReadC"; break;
case Type::AddToPipeline: result = "AddToPipeline"; break;
case Type::WriteFromPipeline: result = "WriteFromPipeline"; break;
}
result += " address:" + std::to_string(address) + " value:" + std::to_string(value);
return result;
}
};
std::vector<Transaction> get_and_reset_transactions();
2021-07-22 22:43:07 +00:00
private:
int width_ = 0, height_ = 0;
int shifts_[2]{};
2021-09-26 23:18:12 +00:00
uint16_t a_mask_[2] = {0xffff, 0xffff};
bool line_mode_ = false;
2021-09-26 23:18:12 +00:00
bool one_dot_ = false;
int line_direction_ = 0;
int line_sign_ = 1;
uint32_t direction_ = 1;
2021-09-29 02:11:58 +00:00
bool inclusive_fill_ = false;
bool exclusive_fill_ = false;
bool fill_carry_ = false;
2021-09-26 23:18:12 +00:00
uint8_t minterms_ = 0;
2021-09-24 02:05:59 +00:00
uint32_t a32_ = 0, b32_ = 0;
uint16_t a_data_ = 0, b_data_ = 0, c_data_ = 0;
2021-09-21 03:08:26 +00:00
2021-10-29 01:12:46 +00:00
bool not_zero_flag_ = false;
BlitterSequencer sequencer_;
uint32_t write_address_ = 0xffff'ffff;
uint16_t write_value_ = 0;
enum WritePhase {
Starting, Full
} write_phase_;
int y_, x_;
uint16_t transient_a_mask_;
2022-07-31 00:34:37 +00:00
bool busy_ = false;
int loop_index_ = -1;
int error_ = 0;
bool draw_ = false;
bool has_c_data_ = false;
void add_modulos();
std::vector<Transaction> transactions_;
2021-07-22 22:43:07 +00:00
};
}