SpritesMind.Net

Code: Select all

  auto output = io.backgroundColor;
//The backdrop is shown at half intensity, while the overscan region outside
//of the display area is always shown at normal intensity.
  enum : uint { Normal, Shadow, Highlight } mode = Shadow;

  if(!planeB.output.priority) if(auto color = planeB.output.color) {
    output = color;
//Background tiles are shown at half intensity, or at normal intensity if their priority bit is set.
    mode = Shadow;
  }
  if(!planeA.output.priority) if(auto color = planeA.output.color) {
    output = color;
    mode = Shadow;
  }
  if(!sprite.output.priority) if(auto color = sprite.output.color) {
//Sprites with colour 15 of palette 4 will highlight the underlying pixels -
//if the underlying pixel is shadowed, it will be displayed normally.
//If it's already normal, it will be highlighted.
//** note this contradicts Charles MacDonald:
//Pixels with color 3Eh are not drawn. Instead, the underlying pixel
//(from the backdrop or background) will be shown at half intensity.
         if(color == 0x3e) mode = mode == Shadow ? Normal : Highlight;
//Sprites with colour 16 of palette 4 will shadow the underlying pixels -
//if the underlying pixel is normal, it will be shadowed. If it is shadowed, nothing will occur.
//If it's highlighted, it will be displayed normally.
//** same
//Pixels with color 3Fh are not drawn. Instead, the underlying pixel
//(from the backdrop or background) will be shown at double intensity.
    else if(color == 0x3f) mode = Shadow;
    else {
      output = color;
//Colors 0Eh, 1Eh, 2Eh, are always shown at normal intensity regardless of priority.
//I'd say this a bug rather than a feature.
      mode = color == 0x0e || color == 0x1e || color == 0x2e ? Normal : Shadow;
    }
  }
  if( planeB.output.priority) if(auto color = planeB.output.color) {
    output = color;
//Background tiles are shown at half intensity, or at normal intensity if their priority bit is set.
    mode = Normal;
  }
  if( planeA.output.priority) if(auto color = planeA.output.color) {
    output = color;
    mode = Normal;
  }
  if( sprite.output.priority) if(auto color = sprite.output.color) {
         if(color == 0x3e) mode = mode == Shadow ? Normal : Highlight;
    else if(color == 0x3f) mode = Shadow;
    else {
      output = color;
      mode = Normal;
    }
  }

  auto color = cram.read(output);

//Background tiles are shown at half intensity, or at normal intensity if their priority bit is set.
//In the latter case, this affects all other graphics elements in the region (usually 8x8) that the
//tile takes up, regardless of the tile containing opaque pixels or not.
//*** this is flawed. If we do this, shadow mode breaks on the fourth column of colors.
//if(planeB.output.priority || planeA.output.priority) mode = Normal;

  //this is lazy, I know I'm cutting 50% of the color precision away, and that the actual colors are non-linear
  //don't worry, when I get the demo working I'll make a proper LUT for all three modes
  if(mode == Shadow   ) color = (color >> 1) & 0b011011011;
  if(mode == Highlight) color = (color << 1) & 0b110110110;

  outputPixel(color);
}

Code: Select all

auto VDP::run() -> void {
  if(!io.displayEnable) return outputPixel(0);
  if(state.vcounter >= screenHeight()) return outputPixel(0);

  auto& planeA = window.isWindowed(state.hdot, state.vcounter) ? window : this->planeA;
  planeA.run(state.hdot, state.vcounter);
  planeB.run(state.hdot, state.vcounter);
  sprite.run(state.hdot, state.vcounter);

  Pixel z = {io.backgroundColor, 0};
  Pixel a = planeA.output;
  Pixel b = planeB.output;
  Pixel s = sprite.output;

  auto& bg = a.above() || a.color && !b.above() ? a : b.color ? b : z;
  auto& fg = s.above() || s.color && !a.above() && !b.above() ? s : bg;
  uint mode = a.priority || b.priority;

  if(&fg == &s) switch(s.color) {
  case 0x0e:
  case 0x1e:
  case 0x2e: mode  = 1; break;
  case 0x3e: mode += 1; fg = bg; break;
  case 0x3f: mode  = 0; fg = bg; break;
  default:   mode |= s.priority; break;
  }

  auto color = cram.read(fg.color);
  if(!io.shadowHighlightEnable) mode = 1;
  if(mode == 0) color = (color >> 1) & 0b011011011;  //todo: separate LUTs for more precision
  if(mode == 2) color = (color << 1) & 0b110110110;  //and also for non-linear color response
  outputPixel(color);

  state.hdot++;
}