public int DrawCostume(VirtScreen vs, int numStrips, Actor actor, bool drawToBackBuf) { var pixelsNavigator = new PixelNavigator(vs.Surfaces[drawToBackBuf ? 1 : 0]); pixelsNavigator.OffsetX(vs.XStart); ActorX += (vs.XStart & 7); pixelsNavigator.OffsetX(-(vs.XStart & 7)); startNav = new PixelNavigator(pixelsNavigator); if (_vm.Game.IsOldBundle) { _xmove = -72; _ymove = -100; } else { _xmove = _ymove = 0; } int result = 0; for (int i = 0; i < 16; i++) { result |= DrawLimb(actor, i); } return(result); }
public void DrawBitmap(ImageData img, VirtScreen vs, int x, int y, int width, int height, int stripnr, int numstrip, int roomWidth, DrawBitmaps flags) { // Check whether lights are turned on or not var lightsOn = _vm.IsLightOn(); DrawBitmap(img, vs, new Point(x, y), width, height, stripnr, numstrip, roomWidth, flags, lightsOn); }
protected override void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { if (_objectMode) { var imgData = (ImageData1)img; objectMap = imgData.ObjectMap; } }
protected override void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { if (_objectMode) { var imgData = (ImageData1)img; objectMap = imgData.ObjectMap; } }
protected CharsetRenderer(ScummEngine vm) { Top = 0; Left = 0; StartLeft = 0; Right = 0; Color = 0; Center = false; HasMask = false; TextScreen = vm.MainVirtScreen; BlitAlso = false; FirstChar = false; DisableOffsX = false; Vm = vm; CurId = -1; }
protected CharsetRenderer(ScummEngine vm) { Top = 0; Left = 0; StartLeft = 0; Right = 0; Color = 0; Center = false; HasMask = false; TextScreen = vm.MainVirtScreen; BlitAlso = false; FirstChar = false; DisableOffsX = false; Vm = vm; CurId = -1; }
void UpdateDirtyScreen(VirtScreen vs) { // Do nothing for unused virtual screens if (vs.Height == 0) return; int i; int w = 8; int start = 0; for (i = 0; i < Gdi.NumStrips; i++) { if (vs.BDirty[i] != 0) { int top = vs.TDirty[i]; int bottom = vs.BDirty[i]; vs.TDirty[i] = vs.Height; vs.BDirty[i] = 0; if (i != (Gdi.NumStrips - 1) && vs.BDirty[i + 1] == bottom && vs.TDirty[i + 1] == top) { // Simple optimizations: if two or more neighboring strips // form one bigger rectangle, coalesce them. w += 8; continue; } DrawStripToScreen(vs, start * 8, w, top, bottom); w = 8; } start = i + 1; } }
void DumpRoomObjectImages(Room room, ObjectData obj, Gdi gdi) { var text = new ScummText(obj.Name); var sb = new StringBuilder(); sb.Append("Object #" + obj.Number).Append(" "); var decoder = new TextDecoder(sb); text.Decode(decoder); sb.AppendFormat(" size: {0}x{1}", obj.Width, obj.Height); Console.WriteLine(sb); var j = 0; foreach (var img in obj.Images) { // try // { var screen = new VirtScreen(0, obj.Width, obj.Height, PixelFormat.Indexed8, 2); if (img.IsBomp) { var bdd = new BompDrawData(); bdd.Src = img.Data; bdd.Dst = new PixelNavigator(screen.Surfaces[0]); bdd.X = 0; bdd.Y = 0; bdd.Width = obj.Width; bdd.Height = obj.Height; bdd.ScaleX = 255; bdd.ScaleY = 255; bdd.DrawBomp(); } else { gdi.DrawBitmap(img, screen, new Point(0, 0), obj.Width, obj.Height & 0xFFF8, 0, obj.Width / 8, room.Header.Width, DrawBitmaps.None, true); } using (var bmp = ToBitmap(room, screen)) { bmp.Save("obj_" + obj.Number + "_" + (++j) + ".png"); } // } // catch (Exception e) // { // Console.ForegroundColor = ConsoleColor.Red; // Console.WriteLine(e); // Console.ResetColor(); // Console.ReadLine(); // } } }
void DumpRoomImage(Room room, Gdi gdi) { var name = room.Name ?? "room_" + room.Number; var screen = new VirtScreen(0, room.Header.Width, room.Header.Height, PixelFormat.Indexed8, 2); var numStrips = room.Header.Width / 8; gdi.NumStrips = numStrips; gdi.IsZBufferEnabled = false; if (room.Header.Height > 0) { gdi.RoomChanged(room); gdi.DrawBitmap(room.Image, screen, new Point(), room.Header.Width, room.Header.Height, 0, numStrips, room.Header.Width, 0, true); using (var bmpRoom = ToBitmap(room, screen)) { bmpRoom.Save(name + ".png"); } } DumpZPlanes(room, name); }
internal void StartScene(byte room, Actor a = null, int objectNr = 0) { StopTalk(); FadeOut(_switchRoomEffect2); _newEffect = _switchRoomEffect; if (CurrentScript != 0xFF) { if (_slots[CurrentScript].Where == WhereIsObject.Room || _slots[CurrentScript].Where == WhereIsObject.FLObject) { //nukeArrays(CurrentScript); CurrentScript = 0xFF; } else if (_slots[CurrentScript].Where == WhereIsObject.Local) { //if (slots[CurrentScript].cutsceneOverride && _game.version >= 5) // error("Script %d stopped with active cutscene/override in exit", slots[CurrentScript].number); //nukeArrays(CurrentScript); CurrentScript = 0xFF; } } if (VariableNewRoom.HasValue) _variables[VariableNewRoom.Value] = room; RunExitScript(); KillScriptsAndResources(); if (_game.Version >= 4) { StopCycle(0); } for (var i = 1; i < Actors.Length; i++) { Actors[i].Hide(); } if (Game.Version >= 7) { // Set the shadow palette(s) to all black. This fixes // bug #795940, and actually makes some sense (after all, // shadows tend to be rather black, don't they? ;-) Array.Clear(_shadowPalette, 0, _shadowPalette.Length); } else { for (var i = 0; i < 256; i++) { Gdi.RoomPalette[i] = (byte)i; if (_shadowPalette != null) _shadowPalette[i] = (byte)i; } if (Game.Version < 5) { SetDirtyColors(0, 255); } } Variables[VariableRoom.Value] = room; _fullRedraw = true; _currentRoom = room; if (room >= 0x80 && Game.Version < 7) _roomResource = _resourceMapper[room & 0x7F]; else _roomResource = room; if (VariableRoomResource.HasValue) Variables[VariableRoomResource.Value] = _roomResource; if (room != 0) ResourceManager.LoadRoom(room); if (room != 0 && _game.Version == 5 && room == _roomResource) Variables[VariableRoomFlag.Value] = 1; ClearRoomObjects(); if (_currentRoom == 0) { if (roomData != null) { _ignoreEntryExitScript = true; roomData.ExitScript.Data = new byte[0]; //roomData.Objects.Clear(); } return; } roomData = _resManager.GetRoom(_roomResource); _ignoreEntryExitScript = false; if (roomData.HasPalette) { SetCurrentPalette(0); } Gdi.NumZBuffer = GetNumZBuffers(); Gdi.TransparentColor = roomData.TransparentColor; ResetRoomSubBlocks(); ResetRoomObjects(); _drawingObjects.Clear(); if (Game.Version >= 7) { // Resize main virtual screen in V7 games. This is necessary // because in V7, rooms may be higher than one screen, so we have // to accomodate for that. _mainVirtScreen = new VirtScreen(MainVirtScreen.TopLine, ScreenWidth, roomData.Header.Height - MainVirtScreen.TopLine, MainVirtScreen.PixelFormat, 2, true); } Gdi.SetMaskHeight(roomData.Header.Height); if (VariableRoomWidth.HasValue && VariableRoomHeight.HasValue) { Variables[VariableRoomWidth.Value] = roomData.Header.Width; Variables[VariableRoomHeight.Value] = roomData.Header.Height; } if (VariableCameraMinX.HasValue) { _variables[VariableCameraMinX.Value] = ScreenWidth / 2; } if (VariableCameraMaxX.HasValue) { _variables[VariableCameraMaxX.Value] = roomData.Header.Width - (ScreenWidth / 2); } if (Game.Version >= 7) { Variables[VariableCameraMinY.Value] = ScreenHeight / 2; Variables[VariableCameraMaxY.Value] = roomData.Header.Height - (ScreenHeight / 2); SetCameraAt(new Point((ScreenWidth / 2), (ScreenHeight / 2))); } else { _camera.Mode = CameraMode.Normal; _camera.CurrentPosition.X = _camera.DestinationPosition.X = (ScreenWidth / 2); _camera.CurrentPosition.Y = _camera.DestinationPosition.Y = (ScreenHeight / 2); } if (_roomResource == 0) return; Gdi.ClearGfxUsageBits(); if (_game.Version >= 5 && a != null) { var where = GetWhereIsObject(objectNr); if (where != WhereIsObject.Room && where != WhereIsObject.FLObject) throw new NotSupportedException(string.Format("StartScene: Object {0} is not in room {1}", objectNr, _currentRoom)); Point pos; int dir; GetObjectXYPos(objectNr, out pos, out dir); a.PutActor(pos, _currentRoom); a.SetDirection(dir + 180); a.StopActorMoving(); if (Game.GameId == Scumm.IO.GameId.SamNMax) { Camera.CurrentPosition.X = Camera.DestinationPosition.X = a.Position.X; SetCameraAt(a.Position); } } ShowActors(); EgoPositioned = false; TownsResetPalCycleFields(); RunEntryScript(); if (Game.Version >= 1 && Game.Version <= 2) { RunScript(5, false, false, new int[0]); } else if ((Game.Version >= 5) && (Game.Version <= 6)) { if (a != null && !EgoPositioned) { var pos = GetObjectXYPos(objectNr); a.PutActor(pos, _currentRoom); a.Moving = 0; } } else if (_game.Version >= 7) { if (Camera.ActorToFollow != 0) { a = Actors[Camera.ActorToFollow]; SetCameraAt(a.Position); } } _doEffect = true; // Hint the backend about the virtual keyboard during copy protection screens if (_game.GameId == GameId.Monkey2) { if (room == 108) _inputManager.ShowVirtualKeyboard(); else _inputManager.HideVirtualKeyboard(); } else if (_game.GameId == GameId.Monkey1 && _game.Variant == "ega") { // this is my estimation that the room code is 90 (untested) if (room == 90) _inputManager.ShowVirtualKeyboard(); else _inputManager.HideVirtualKeyboard(); } }
void PrintCharIntern(byte[] fontPtr, int charPos, int origWidth, int origHeight, int width, int height, VirtScreen vs, bool ignoreCharsetMask) { int drawTop = Top - vs.TopLine; PixelNavigator?back = null; PixelNavigator dstPtr; Surface dstSurface; if ((ignoreCharsetMask || !vs.HasTwoBuffers)) { dstSurface = vs.Surfaces[0]; dstPtr = new PixelNavigator(vs.Surfaces[0]); dstPtr.GoTo(vs.XStart + Left, drawTop); } else { dstSurface = Vm.TextSurface; dstPtr = new PixelNavigator(dstSurface); dstPtr.GoTo(Left, Top - Vm.ScreenTop); } if (BlitAlso && vs.HasTwoBuffers) { back = dstPtr; dstSurface = vs.Surfaces[0]; dstPtr = new PixelNavigator(dstSurface); dstPtr.GoTo(vs.XStart + Left, drawTop); } if (!ignoreCharsetMask && vs.HasTwoBuffers) { drawTop = Top - Vm.ScreenTop; } DrawBitsN(dstSurface, dstPtr, fontPtr, charPos, fontPtr[_fontPos], drawTop, origWidth, origHeight); if (BlitAlso && vs.HasTwoBuffers) { // FIXME: Revisiting this code, I think the _blitAlso mode is likely broken // right now -- we are copying stuff from "dstPtr" to "back", but "dstPtr" really // only conatains charset data... // One way to fix this: don't copy etc.; rather simply render the char twice, // once to each of the two buffers. That should hypothetically yield // identical results, though I didn't try it and right now I don't know // any spots where I can test this... if (!ignoreCharsetMask) { throw new NotSupportedException("This might be broken -- please report where you encountered this to Fingolfin"); } // Perform some clipping int w = Math.Min(width, dstSurface.Width - Left); int h = Math.Min(height, dstSurface.Height - drawTop); if (Left < 0) { w += Left; back.Value.OffsetX(-Left); dstPtr.OffsetX(-Left); } if (drawTop < 0) { h += drawTop; back.Value.OffsetY(-drawTop); dstPtr.OffsetY(-drawTop); } // Blit the image data if (w > 0) { while (h-- > 0) { for (int i = 0; i < w; i++) { back.Value.Write(dstPtr.Read()); back.Value.OffsetX(1); dstPtr.OffsetX(1); } back.Value.Offset(-w, 1); dstPtr.Offset(-w, 1); } } } }
public int DrawCostume(VirtScreen vs, int numStrips, Actor actor, bool drawToBackBuf) { var pixelsNavigator = new PixelNavigator(vs.Surfaces[drawToBackBuf ? 1 : 0]); pixelsNavigator.OffsetX(vs.XStart); ActorX += (vs.XStart & 7); _w = vs.Width; _h = vs.Height; pixelsNavigator.OffsetX(-(vs.XStart & 7)); startNav = new PixelNavigator(pixelsNavigator); if (_vm.Game.Version <= 1) { _xmove = 0; _ymove = 0; } else if (_vm.Game.IsOldBundle) { _xmove = -72; _ymove = -100; } else { _xmove = _ymove = 0; } int result = 0; for (int i = 0; i < 16; i++) result |= DrawLimb(actor, i); return result; }
protected override void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { var ptr = img.Data; // // Since V3, all graphics data was encoded in strips, which is very efficient // for redrawing only parts of the screen. However, V2 is different: here // the whole graphics are encoded as one big chunk. That makes it rather // difficult to draw only parts of a room/object. We handle the V2 graphics // differently from all other (newer) graphic formats for this reason. // var table = (_objectMode ? null : _roomStrips); int left = (stripnr * 8); int right = left + (numstrip * 8); PixelNavigator navDst; var srcOffset = 0; byte color, data = 0; int run; bool dither = false; byte[] dither_table = new byte[128]; var ditherOffset = 0; int theX, theY, maxX; var surface = vs.HasTwoBuffers ? vs.Surfaces[1] : vs.Surfaces[0]; navDst = new PixelNavigator(surface); navDst.GoTo(p.X * 8, p.Y); var mask_ptr = GetMaskBuffer(p.X, p.Y, 1); if (table != null) { run = table.run[stripnr]; color = (byte)table.color[stripnr]; srcOffset = table.offsets[stripnr]; theX = left; maxX = right; } else { run = 1; color = 0; srcOffset = 0; theX = 0; maxX = width; } // Decode and draw the image data. Debug.Assert(height <= 128); for (; theX < maxX; theX++) { ditherOffset = 0; for (theY = 0; theY < height; theY++) { if (--run == 0) { data = ptr[srcOffset++]; if ((data & 0x80) != 0) { run = data & 0x7f; dither = true; } else { run = data >> 4; dither = false; } color = RoomPalette[data & 0x0f]; if (run == 0) { run = ptr[srcOffset++]; } } if (!dither) { dither_table[ditherOffset] = color; } if (left <= theX && theX < right) { navDst.Write(dither_table[ditherOffset++]); navDst.OffsetY(1); } } if (left <= theX && theX < right) { navDst.Offset(1, -height); } } // Draw mask (zplane) data theY = 0; if (table != null) { srcOffset = table.zoffsets[stripnr]; run = table.zrun[stripnr]; theX = left; } else { run = ptr[srcOffset++]; theX = 0; } while (theX < right) { byte runFlag = (byte)(run & 0x80); if (runFlag != 0) { run &= 0x7f; data = ptr[srcOffset++]; } do { if (runFlag == 0) data = ptr[srcOffset++]; if (left <= theX) { mask_ptr.Write(data); mask_ptr.OffsetY(1); } theY++; if (theY >= height) { if (left <= theX) { mask_ptr.Offset(1, -height); } theY = 0; theX += 8; if (theX >= right) break; } } while ((--run) != 0); run = ptr[srcOffset++]; } }
static bool VirtScreenContains(VirtScreen vs, int y) { return (y >= vs.TopLine && y < vs.TopLine + vs.Height); }
internal void MarkRectAsDirty(VirtScreen vs, Rect r, int dirtybit = 0) { MarkRectAsDirty(vs, r.Left, r.Right, r.Top, r.Bottom, dirtybit); }
/// <summary> /// Blit the specified rectangle from the given virtual screen to the display. /// Note: t and b are in *virtual screen* coordinates, while x is relative to /// the *real screen*. This is due to the way tdirty/vdirty work: they are /// arrays which map 'strips' (sections of the real screen) to dirty areas as /// specified by top/bottom coordinate in the virtual screen. /// </summary> /// <param name="vs"></param> /// <param name="x"></param> /// <param name="width"></param> /// <param name="top"></param> /// <param name="bottom"></param> void DrawStripToScreen(VirtScreen vs, int x, int width, int top, int bottom) { // Short-circuit if nothing has to be drawn if (bottom <= top || top >= vs.Height) return; // Perform some clipping if (width > vs.Width - x) width = vs.Width - x; if (top < ScreenTop) top = ScreenTop; if (bottom > ScreenTop + ScreenHeight) bottom = ScreenTop + ScreenHeight; // Convert the vertical coordinates to real screen coords int y = vs.TopLine + top - ScreenTop; int height = bottom - top; if (width <= 0 || height <= 0) return; byte[] src; if (Game.Version < 7) { if (Game.Platform == Platform.FMTowns) { TownsDrawStripToScreen(vs, x, y, x, top, width, height); return; } var srcNav = new PixelNavigator(vs.Surfaces[0]); srcNav.GoTo(vs.XStart + x, top); var compNav = new PixelNavigator(_composite); var txtNav = new PixelNavigator(_textSurface); int m = _textSurfaceMultiplier; txtNav.GoTo(x * m, y * m); var vsPitch = vs.Pitch - width * vs.BytesPerPixel; var textPitch = _textSurface.Pitch - width * m; for (int h = height * m; h > 0; --h) { for (int w = width * m; w > 0; w--) { var temp = txtNav.Read(); int mask = temp ^ CharsetMaskTransparency; mask = (((mask & 0x7f) + 0x7f) | mask) & 0x80; mask = ((mask >> 7) + 0x7f) ^ 0x80; var dst = ((temp ^ srcNav.Read()) & mask) ^ temp; compNav.Write((byte)dst); srcNav.OffsetX(1); txtNav.OffsetX(1); compNav.OffsetX(1); } srcNav.OffsetX(vsPitch); txtNav.OffsetX(textPitch); } src = _composite.Pixels; } else { src = new byte[width * height * vs.BytesPerPixel]; var srcNav = new PixelNavigator(vs.Surfaces[0]); srcNav.GoTo(vs.XStart + x, top); for (int h = 0; h < height; h++) { for (int w = 0; w < width; w++) { src[h * width + w] = srcNav.Read(); srcNav.OffsetX(1); } srcNav.Offset(-width, 1); } } // Finally blit the whole thing to the screen _gfxManager.CopyRectToScreen(src, width * vs.BytesPerPixel, x, y, width, height); }
protected virtual void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { }
public void DrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip, int roomWidth, DrawBitmaps flags, bool isLightOn) { var x = p.X; var y = p.Y; if ((_vm.TownsPaletteFlags & 2) != 0) { int cx = (x - _vm.ScreenStartStrip) << 3; Gdi.Fill(_vm.TextSurface, new Rect(cx * _vm.TextSurfaceMultiplier, y * _vm.TextSurfaceMultiplier, (cx + width - 1) * _vm.TextSurfaceMultiplier, (y + height - 1) * _vm.TextSurfaceMultiplier), 0); } _objectMode = flags.HasFlag(DrawBitmaps.ObjectMode); PrepareDrawBitmap(img, vs, p, width, height, stripnr, numstrip); int sx = x - vs.XStart / 8; if (sx < 0) { numstrip -= -sx; x += -sx; stripnr += -sx; sx = 0; } // Compute the number of strips we have to iterate over. // TODO/FIXME: The computation of its initial value looks very fishy. // It was added as a kind of hack to fix some corner cases, but it compares // the room width to the virtual screen width; but the former should always // be bigger than the latter (except for MM NES, maybe)... strange int limit = Math.Max(roomWidth, vs.Width) / 8 - x; if (limit > numstrip) limit = numstrip; if (limit > NumStrips - sx) limit = NumStrips - sx; for (int k = 0; k < limit; ++k, ++stripnr, ++sx, ++x) { if (y < vs.TDirty[sx]) vs.TDirty[sx] = y; if (y + height > vs.BDirty[sx]) vs.BDirty[sx] = y + height; // In the case of a double buffered virtual screen, we draw to // the backbuffer, otherwise to the primary surface memory. var surface = vs.HasTwoBuffers ? vs.Surfaces[1] : vs.Surfaces[0]; var navDst = new PixelNavigator(surface); navDst.GoTo(x * 8, y); bool transpStrip; using (var smapReader = new BinaryReader(new MemoryStream(img.Data))) { transpStrip = DrawStrip(navDst, width, height, stripnr, smapReader); } // COMI and HE games only uses flag value if (game.Version == 8) transpStrip = true; if (vs.HasTwoBuffers) { var navFrontBuf = new PixelNavigator(vs.Surfaces[0]); navFrontBuf.GoTo(x * 8, y); if (isLightOn) Copy8Col(navFrontBuf, navDst, height); else Clear8Col(navFrontBuf, height); } DecodeMask(x, y, width, height, stripnr, img.ZPlanes, transpStrip, flags); } }
public void DrawBitmap(ImageData img, VirtScreen vs, int x, int y, int width, int height, int stripnr, int numstrip, int roomWidth, DrawBitmaps flags) { // Check whether lights are turned on or not var lightsOn = _vm.IsLightOn(); DrawBitmap(img, vs, new Point(x, y), width, height, stripnr, numstrip, roomWidth, flags, lightsOn); }
protected void TownsDrawStripToScreen(VirtScreen vs, int dstX, int dstY, int srcX, int srcY, int width, int height) { if (width <= 0 || height <= 0) return; int m = _textSurfaceMultiplier; var src1 = new PixelNavigator(vs.Surfaces[0]); src1.GoTo(vs.XStart + srcX, srcY); var src2 = new PixelNavigator(_textSurface); src2.GoTo(srcX * m, (srcY + vs.TopLine - ScreenTop) * m); var dst1 = new PixelNavigator(_townsScreen.GetLayerPixels(0, dstX, dstY).Value); var dst2 = new PixelNavigator(_townsScreen.GetLayerPixels(1, dstX * m, dstY * m).Value); int dp1 = _townsScreen.GetLayerPitch(0) - width * _townsScreen.GetLayerBpp(0); int dp2 = _townsScreen.GetLayerPitch(1) - width * m * _townsScreen.GetLayerBpp(1); int sp1 = vs.Pitch - (width * Surface.GetBytesPerPixel(vs.PixelFormat)); int sp2 = _textSurface.Pitch - width * m; if (vs == MainVirtScreen || Game.GameId == GameId.Indy3 || Game.GameId == GameId.Zak) { for (int h = 0; h < height; ++h) { if (Surface.GetBytesPerPixel(_gfxManager.PixelFormat) == 2) { for (int w = 0; w < width; ++w) { dst1.WriteUInt16(_16BitPalette[src1.Read()]); src1.OffsetX(1); dst1.OffsetX(1); } src1.OffsetX(sp1 / src1.BytesByPixel); dst1.OffsetX(dp1 / dst1.BytesByPixel); } else { for (int i = 0; i < width; i++) { dst1.Write(src1.Read()); dst1.OffsetX(1); src1.OffsetX(1); } } for (int sH = 0; sH < m; ++sH) { for (int i = 0; i < width * m; i++) { dst2.Write(src2.Read()); src2.OffsetX(1); dst2.OffsetX(1); } src2.OffsetX(_textSurface.Width - (width * m)); dst2.OffsetX(dst2.Width - (width * m)); } } } else { dst1 = new PixelNavigator(dst2); for (int h = 0; h < height; ++h) { for (int w = 0; w < width; ++w) { var t = (src1.Read()) & 0x0f; src1.OffsetX(1); for (int i = 0; i < m; i++) { dst1.Write((byte)((t << 4) | t)); dst1.OffsetX(1); } } dst1 = new PixelNavigator(dst2); var src3 = new PixelNavigator(src2); if (m == 2) { dst2.OffsetY(1); src3.OffsetY(1); } for (int w = 0; w < width * m; ++w) { dst2.Write((byte)(src3.Read() | dst1.Read() & _townsLayer2Mask[src3.Read()])); dst2.OffsetX(1); dst1.Write((byte)(src2.Read() | dst1.Read() & _townsLayer2Mask[src2.Read()])); src2.OffsetX(1); src3.OffsetX(1); dst1.OffsetX(1); } src1.OffsetX(sp1 / src1.BytesByPixel); src2 = new PixelNavigator(src3); src2.OffsetX(sp2 / src2.BytesByPixel); dst1 = new PixelNavigator(dst2); dst1.OffsetX(dp2 / dst1.BytesByPixel); dst2.OffsetX(dp2 / dst2.BytesByPixel); } } _townsScreen.AddDirtyRect(dstX * m, dstY * m, width * m, height * m); }
public void DrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip, int roomWidth, DrawBitmaps flags, bool isLightOn) { var x = p.X; var y = p.Y; if ((_vm.TownsPaletteFlags & 2) != 0) { int cx = (x - _vm.ScreenStartStrip) << 3; Gdi.Fill(_vm.TextSurface, new Rect(cx * _vm.TextSurfaceMultiplier, y * _vm.TextSurfaceMultiplier, (cx + width - 1) * _vm.TextSurfaceMultiplier, (y + height - 1) * _vm.TextSurfaceMultiplier), 0); } _objectMode = flags.HasFlag(DrawBitmaps.ObjectMode); PrepareDrawBitmap(img, vs, p, width, height, stripnr, numstrip); int sx = x - vs.XStart / 8; if (sx < 0) { numstrip -= -sx; x += -sx; stripnr += -sx; sx = 0; } // Compute the number of strips we have to iterate over. // TODO/FIXME: The computation of its initial value looks very fishy. // It was added as a kind of hack to fix some corner cases, but it compares // the room width to the virtual screen width; but the former should always // be bigger than the latter (except for MM NES, maybe)... strange int limit = Math.Max(roomWidth, vs.Width) / 8 - x; if (limit > numstrip) { limit = numstrip; } if (limit > NumStrips - sx) { limit = NumStrips - sx; } for (int k = 0; k < limit; ++k, ++stripnr, ++sx, ++x) { if (y < vs.TDirty[sx]) { vs.TDirty[sx] = y; } if (y + height > vs.BDirty[sx]) { vs.BDirty[sx] = y + height; } // In the case of a double buffered virtual screen, we draw to // the backbuffer, otherwise to the primary surface memory. var surface = vs.HasTwoBuffers ? vs.Surfaces[1] : vs.Surfaces[0]; var navDst = new PixelNavigator(surface); navDst.GoTo(x * 8, y); bool transpStrip; using (var smapReader = new BinaryReader(new MemoryStream(img.Data))) { transpStrip = DrawStrip(navDst, width, height, stripnr, smapReader); } // COMI and HE games only uses flag value if (game.Version == 8) { transpStrip = true; } if (vs.HasTwoBuffers) { var navFrontBuf = new PixelNavigator(vs.Surfaces[0]); navFrontBuf.GoTo(x * 8, y); if (isLightOn) { Copy8Col(navFrontBuf, navDst, height); } else { Clear8Col(navFrontBuf, height); } } DecodeMask(x, y, width, height, stripnr, img.ZPlanes, transpStrip, flags); } }
internal void MarkRectAsDirty(VirtScreen vs, int left, int right, int top, int bottom, int dirtybit = 0) { int lp, rp; if (left > right || top > bottom) return; if (top > vs.Height || bottom < 0) return; if (top < 0) top = 0; if (bottom > vs.Height) bottom = vs.Height; if (vs == MainVirtScreen && dirtybit != 0) { lp = left / 8 + _screenStartStrip; if (lp < 0) lp = 0; rp = (right + vs.XStart) / 8; if (_game.Version >= 7) { if (rp > 409) rp = 409; } else { if (rp >= 200) rp = 200; } for (; lp <= rp; lp++) Gdi.SetGfxUsageBit(lp, dirtybit); } // The following code used to be in the separate method setVirtscreenDirty lp = left / 8; rp = right / 8; if ((lp >= Gdi.NumStrips) || (rp < 0)) return; if (lp < 0) lp = 0; if (rp >= Gdi.NumStrips) rp = Gdi.NumStrips - 1; while (lp <= rp) { if (top < vs.TDirty[lp]) vs.TDirty[lp] = top; if (bottom > vs.BDirty[lp]) vs.BDirty[lp] = bottom; lp++; } }
protected virtual void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { }
public override void PrintChar(int chr, bool ignoreCharsetMask) { Rect shadow; Debug.Assert(_current != null); if (chr == '@') { return; } shadow.Left = Left; shadow.Top = Top; if (FirstChar) { Str.Left = (shadow.Left >= 0) ? shadow.Left : 0; Str.Top = (shadow.Top >= 0) ? shadow.Top : 0; Str.Right = Str.Left; Str.Bottom = Str.Top; FirstChar = false; } int width = _current.GetCharWidth((char)chr); int height = _current.GetCharHeight((char)chr); // bool is2byte = chr >= 256 && _vm._useCJKMode; // if (is2byte) // width = _vm._2byteWidth; shadow.Right = Left + width; shadow.Bottom = Top + height; Surface s; if (!ignoreCharsetMask) { HasMask = true; TextScreen = Vm.MainVirtScreen; } int offsetX = 0; int drawTop = Top; if (ignoreCharsetMask) { VirtScreen vs = Vm.MainVirtScreen; s = vs.Surfaces[0]; offsetX = vs.XStart; } else { s = Vm.TextSurface; drawTop -= Vm.ScreenTop; } var dst = new PixelNavigator(s); dst.GoTo(Left + offsetX, drawTop); // if (chr >= 256 && _vm._useCJKMode) // _current.draw2byte(s, chr, _left, drawTop, _color); // else _current.DrawChar(dst, (char)chr, Left, drawTop, Color); Vm.MarkRectAsDirty(Vm.MainVirtScreen, shadow); if (Str.Left > Left) { Str.Left = Left; } // Original keeps glyph width and character dimensions separately // if ((_vm._language == Common::ZH_TWN || _vm._language == Common::KO_KOR) && is2byte) // width++; Left += width; if (Str.Right < shadow.Right) { Str.Right = shadow.Right; } if (Str.Bottom < shadow.Bottom) { Str.Bottom = shadow.Bottom; } }
protected void InitScreens(int b, int h) { if (_townsScreen != null) { if (_townsClearLayerFlag == 0 && MainVirtScreen != null && ((h - b) != MainVirtScreen.Height)) _townsScreen.ClearLayer(0); if (Game.GameId != GameId.Monkey1) { Gdi.Fill(TextSurface, new Rect(0, 0, _textSurface.Width * _textSurfaceMultiplier, _textSurface.Height * _textSurfaceMultiplier), 0); _townsScreen.ClearLayer(1); } } var format = Game.Features.HasFlag(GameFeatures.Is16BitColor) ? PixelFormat.Rgb16 : PixelFormat.Indexed8; _mainVirtScreen = new VirtScreen(b, ScreenWidth, h - b, format, 2, true); _textVirtScreen = new VirtScreen(0, ScreenWidth, b, format, 1); _verbVirtScreen = new VirtScreen(h, ScreenWidth, ScreenHeight - h, format, 1); // Since the size of screen 3 is fixed, there is no need to reallocate // it if its size changed. // Not sure what it is good for, though. I think it may have been used // in pre-V7 for the games messages (like 'Pause', Yes/No dialogs, // version display, etc.). I don't know about V7, maybe the same is the // case there. If so, we could probably just remove it completely. if (_game.Version >= 7) { _unkVirtScreen = new VirtScreen((ScreenHeight / 2) - 10, ScreenWidth, 13, format, 1); } else { _unkVirtScreen = new VirtScreen(80, ScreenWidth, 13, format, 1); } _screenB = b; _screenH = h; Gdi.Init(); }
protected override void PrepareDrawBitmap(ImageData img, VirtScreen vs, Point p, int width, int height, int stripnr, int numstrip) { var ptr = img.Data; // // Since V3, all graphics data was encoded in strips, which is very efficient // for redrawing only parts of the screen. However, V2 is different: here // the whole graphics are encoded as one big chunk. That makes it rather // difficult to draw only parts of a room/object. We handle the V2 graphics // differently from all other (newer) graphic formats for this reason. // var table = (_objectMode ? null : _roomStrips); int left = (stripnr * 8); int right = left + (numstrip * 8); PixelNavigator navDst; var srcOffset = 0; byte color, data = 0; int run; bool dither = false; byte[] dither_table = new byte[128]; var ditherOffset = 0; int theX, theY, maxX; var surface = vs.HasTwoBuffers ? vs.Surfaces[1] : vs.Surfaces[0]; navDst = new PixelNavigator(surface); navDst.GoTo(p.X * 8, p.Y); var mask_ptr = GetMaskBuffer(p.X, p.Y, 1); if (table != null) { run = table.run[stripnr]; color = (byte)table.color[stripnr]; srcOffset = table.offsets[stripnr]; theX = left; maxX = right; } else { run = 1; color = 0; srcOffset = 0; theX = 0; maxX = width; } // Decode and draw the image data. Debug.Assert(height <= 128); for (; theX < maxX; theX++) { ditherOffset = 0; for (theY = 0; theY < height; theY++) { if (--run == 0) { data = ptr[srcOffset++]; if ((data & 0x80) != 0) { run = data & 0x7f; dither = true; } else { run = data >> 4; dither = false; } color = RoomPalette[data & 0x0f]; if (run == 0) { run = ptr[srcOffset++]; } } if (!dither) { dither_table[ditherOffset] = color; } if (left <= theX && theX < right) { navDst.Write(dither_table[ditherOffset++]); navDst.OffsetY(1); } } if (left <= theX && theX < right) { navDst.Offset(1, -height); } } // Draw mask (zplane) data theY = 0; if (table != null) { srcOffset = table.zoffsets[stripnr]; run = table.zrun[stripnr]; theX = left; } else { run = ptr[srcOffset++]; theX = 0; } while (theX < right) { byte runFlag = (byte)(run & 0x80); if (runFlag != 0) { run &= 0x7f; data = ptr[srcOffset++]; } do { if (runFlag == 0) { data = ptr[srcOffset++]; } if (left <= theX) { mask_ptr.Write(data); mask_ptr.OffsetY(1); } theY++; if (theY >= height) { if (left <= theX) { mask_ptr.Offset(1, -height); } theY = 0; theX += 8; if (theX >= right) { break; } } } while ((--run) != 0); run = ptr[srcOffset++]; } }
System.Drawing.Color ToColor(Room room, VirtScreen screen, int x, int y) { var index = screen.Surfaces[0].Pixels[y * screen.Width + x]; var c = Game.Features.HasFlag(GameFeatures.SixteenColors) ? Palette.Cga.Colors[index] : room.Palette.Colors[index]; return System.Drawing.Color.FromArgb(c.R, c.G, c.B); }
void PrintCharIntern(byte[] fontPtr, int charPos, int origWidth, int origHeight, int width, int height, VirtScreen vs, bool ignoreCharsetMask) { int drawTop = Top - vs.TopLine; PixelNavigator? back = null; PixelNavigator dstPtr; Surface dstSurface; if ((ignoreCharsetMask || !vs.HasTwoBuffers)) { dstSurface = vs.Surfaces[0]; dstPtr = new PixelNavigator(vs.Surfaces[0]); dstPtr.GoTo(vs.XStart + Left, drawTop); } else { dstSurface = Vm.TextSurface; dstPtr = new PixelNavigator(dstSurface); dstPtr.GoTo(Left, Top - Vm.ScreenTop); } if (BlitAlso && vs.HasTwoBuffers) { back = dstPtr; dstSurface = vs.Surfaces[0]; dstPtr = new PixelNavigator(dstSurface); dstPtr.GoTo(vs.XStart + Left, drawTop); } if (!ignoreCharsetMask && vs.HasTwoBuffers) { drawTop = Top - Vm.ScreenTop; } DrawBitsN(dstSurface, dstPtr, fontPtr, charPos, fontPtr[_fontPos], drawTop, origWidth, origHeight); if (BlitAlso && vs.HasTwoBuffers) { // FIXME: Revisiting this code, I think the _blitAlso mode is likely broken // right now -- we are copying stuff from "dstPtr" to "back", but "dstPtr" really // only conatains charset data... // One way to fix this: don't copy etc.; rather simply render the char twice, // once to each of the two buffers. That should hypothetically yield // identical results, though I didn't try it and right now I don't know // any spots where I can test this... if (!ignoreCharsetMask) throw new NotSupportedException("This might be broken -- please report where you encountered this to Fingolfin"); // Perform some clipping int w = Math.Min(width, dstSurface.Width - Left); int h = Math.Min(height, dstSurface.Height - drawTop); if (Left < 0) { w += Left; back.Value.OffsetX(-Left); dstPtr.OffsetX(-Left); } if (drawTop < 0) { h += drawTop; back.Value.OffsetY(-drawTop); dstPtr.OffsetY(-drawTop); } // Blit the image data if (w > 0) { while (h-- > 0) { for (int i = 0; i < w; i++) { back.Value.Write(dstPtr.Read()); back.Value.OffsetX(1); dstPtr.OffsetX(1); } back.Value.Offset(-w, 1); dstPtr.Offset(-w, 1); } } } }
System.Drawing.Color ToColor(byte[] pixels, Palette palette, VirtScreen screen, int x, int y) { var index = pixels[y * screen.Width + x]; var c = palette.Colors[index]; return System.Drawing.Color.FromArgb(c.R, c.G, c.B); }
static byte[] Capture(VirtScreen screen, int x, int y, int w, int h) { var pixels = new byte[w * h]; var nav = new PixelNavigator(screen.Surfaces[0]); nav.GoTo(x, y); for (int height = 0; height < h; height++) { for (int width = 0; width < w; width++) { pixels[height * w + width] = nav.Read(); nav.OffsetX(1); } nav.Offset(-w, 1); } return pixels; }
System.Drawing.Bitmap ToBitmap(Room room, VirtScreen screen) { var bmp = new System.Drawing.Bitmap(screen.Width, screen.Height); // DitherCGA(screen.Surfaces[0].Pixels, screen.Surfaces[0].Pitch, 0, 0, screen.Width, screen.Height); var palette = Game.Features.HasFlag(GameFeatures.SixteenColors) ? Palette.Ega : room.Palette; for (int x = 0; x < screen.Width; x++) { for (int y = 0; y < screen.Height; y++) { bmp.SetPixel(x, y, ToColor(screen.Surfaces[0].Pixels, palette, screen, x, y)); } } return bmp; }