NEWS ARTICLES


PlayMAPPER Classic V1 16 Work In Progress

PlayMAPPER Classic V1.16 WIP – New Undo, Brushes, Drawing Tools & More

Welcome back! In this update video I’m walking through the current work-in-progress state of PlayMAPPER Classic V1.16.

I’ve replaced big chunks of the old code and focused on making the tool feel more comfortable and practical to use. Here’s what’s new and improved:


- Proper Undo system (Ctrl+Z) for drawing actions, with an on-screen undo stack

- Completely overhauled Brush system – create, save and insert brushes (like the "ball" example or whole rooms)

- Insert brushes like sprites with transparency support and easy undoing

- Updated circle & line drawing tools that feel much better, track points properly, support undo, and stay in sync with the minimap

- Layer import (F9), multi-layer support (background + front), resize layers, and improved map loading/saving

- Transparent tile index setting

- Lots of internal clean-ups for efficiency (batch updates instead of constant poking both maps, new brush storage using levels instead of a huge 5D array, etc.)



I also show some of the remaining limitations and rough edges (tile selection window with large tilesets, mouse behaviour outside the edit area, missing brush deletion, no proper parallax preview, UI constraints, etc.) and talk about planned next steps like merge-down, export back to standard PlayBASIC levels, better cut/paste, and making the interface clearer.


The goal isn’t to turn this into the ultimate map editor — just to make PlayMAPPER Classic noticeably more convenient for anyone creating maps for PlayBASIC (or anything else you want to use it with).



PlayBASIC Software 3D Engine

PS3D Update Summary – PlayBASIC Software 3D Engine

PS3D continues as an experimental software rendering engine / tech demo built on PlayBASIC’s VertexObjects libraries. It’s a flexible test bed for exploring meshes, polygon rendering, lighting, animation, particles and related 3D techniques.

Recent highlights:

V0.40 – Animated Objects with Lighting
Major milestone: vertex frame animation with smooth keyframe interpolation. Animated meshes (including classic MD2 dragons) now transition seamlessly while retaining full lighting support. Demo moves from a Wolf3D-style environment into an open scene, showing both Gouraud-shaded and fully textured models with dynamic lighting.




V0.44 – Particles Demo
Simple particle operations pushed further. Colourful particle bursts create explosive effects throughout a 3D test scene while the camera freely wanders. Hundreds of particles are animated in real time alongside the existing PS3D pipeline — a deliberately chaotic stress test of movement, manipulation and rendering performance.




More experiments and refinements are ongoing as the engine grows.

PlayBASIC devlog 3D bugs and Collision

In this week's PlayBASIC Devlog we're back inside the PS3D software renderer, tracking down a couple of surprisingly difficult bugs while continuing development of PlayBASIC's retro 3D graphics engine.

The biggest issue was a long-standing rasterization bug that produced flickering pixels along polygon edges during texture mapping with Gouraud shading and adaptive polygon subdivision. As the renderer gained support for ambient lighting and distance fog, these rendering artifacts became much easier to spot, leading to a deep dive into the software rasterizer and a complete fix.

I also investigate an intermittent divide-by-zero crash inside the adaptive subdivision system, explaining why it only occurred from particular camera positions and how the renderer now handles those edge cases correctly.

Along the way we explore how PlayBASIC's software rendering pipeline performs perspective correction, adaptive mesh subdivision, shaded texture rendering, and simple camera collision, while discussing the trade-offs between visual quality and rendering performance.

The second half of the video looks at ideas for the future of the PS3D engine, including visibility culling, mesh editing, mesh merging, dynamic lighting, and building a retro software-rendered FPS inspired by classic 90s games.

If you're interested in *software rendering*, *graphics programming*, *game engine development*, *retro game programming*, *texture mapping*, *polygon rasterization*, or seeing how PlayBASIC continues to evolve under the hood, you'll find plenty of technical discussion throughout this devlog.





PlayBASIC v1.65C3 Beta #82 Released

PlayBASIC v1.65C3 Beta 81/82 (Release Candidate) Released – 2nd June 2026

      V1.65C3 Beta #81/82 is the current build of the compiler, runtimes and HELP FILES. 


      This build includes the TranslateMeshToScene functionality. 

      What's new;

      - Single pass Z clipper (near /far)

      - polygon subdivision (triangles and quad)

      - Added Shade Polygon support to mesh fill types (Combined Texture and Gouraud)

      - Added Point Sprites (a single vertex face type in the mesh. Only support a texture as a FileType.

      - Added Write Frame (Frame) (two vertex) face type to the mesh.  RGB colour comes vertex 1  - Clipped in Near/Far z plane

      - Translate pre-computes image descriptions once, so texturing can look up the surface going through the image -> abstraction.  This changes means that if you translate a mesh with textured images to the scene, then delete the image (or change it's size etc) it'll crash! 


 



      Like always, please test, break things, and post your findings so we can keep refining PlayBASIC!

Download

  Live Betas available through the forums.

Intro to Functions

Intro to Functions (PlayBASIC Tutorial)

In this tutorial, we take the next step beyond classic BASIC flow control and move into structured programming with functions.

We kick things off with a quick refresher on Gosub / Return and how subroutines alter program flow by jumping out to a labeled block of code and then returning to the caller. From there, we break down how this mechanism works under the hood (including the stack and return points), along with some of the common pitfalls—like missing return statements and unpredictable program behaviour in larger projects.

From that foundation, we transition into functions a more modern and structured way to organize your code.

You’ll learn:

* How to convert a simple subroutine into a function
* Why functions are safer and more predictable (compiler checks, defined entry/exit points)
* How to call functions just like built-in commands
* The concept of variable scope (and why your loop counter suddenly stops working!)
* The difference between local and global variables—and why globals aren’t always the best solution
* How to pass data into functions using parameters


We then build on this by creating practical examples:

* A custom distance calculation function (with return values)
* A simple string processing function (trimming and replacing characters)
* Handling different data types (integers, floats, and strings)


By the end of the video, you’ll understand how functions let you break large, messy programs into smaller, reusable, and more manageable pieces—essentially creating your own custom commands inside PlayBASIC.