RenSL 0.2.1

RenSL

RenSL is a reusable .NET class library for CAD, geometry, and lightweight 3D rendering workflows on Windows.

It is a CPU-based renderer designed specifically for WinForms applications, with a built-in 3D rendering control that is surprisingly fast and easy to integrate into desktop tools.

Features

• CPU-based 3D renderer for Windows desktop applications
• Designed specifically for WinForms
• Includes a reusable WinForms 3D rendering control
• Supports loading DXF files
• Supports loading OBJ files
• Supports loading LEGO MPD / LDR files
• Provides an object model for direct access to DXF entities
• Includes geometry and polyline processing helpers
• Includes SHX font support

What RenSL Is Good For

RenSL is a strong fit for applications that need:

• Fast embedded 3D visualization in a WinForms UI
• CAD and geometry import workflows
• Programmatic access to DXF content
• Lightweight rendering without requiring GPU-based pipelines

Version 0.2.1

• Restores letter strokes in underlined SHX text.
• Corrects ACI color 152 in the existing display palette.
• Softens spherical gradient transitions while preserving endpoint colors.

Packaging since 0.2.0

The RenSL package includes both RenSL.dll and RenSL.Core.dll. Continue to reference the single RenSL package in Windows applications; the Portable viewer and its Avalonia dependencies are not included. Core's font and image codec dependencies are restored automatically by NuGet.

Public CAD types moved into Core retain type forwarders in RenSL. This release also changes portable text-style APIs and UnderlayRaster to use PixelSurface; applications using those APIs may need source changes and rebuilding.

Target Framework

• net10.0-windows7.0

Platform Notes

• Windows-focused
• Intended to be referenced by a desktop executable or host application
• Especially well suited for WinForms-based CAD, viewer, and geometry tools

Supported File Formats

RenSL currently supports loading:

• DXF
• OBJ
• LEGO MPD / LDR

Additional DXF entities

MLEADER uses the same importer and renderer as MULTILEADER. RTEXT retains its expression or file reference and renders its saved evaluated text when available. Relative external text files are resolved beside the DXF; multiline and MTEXT-formatted file content is supported. DIESEL expressions are not executed: without saved graphics the expression is retained and displayed literally, with the reason available in ReactiveText.ImportDiagnostic.

ARCALIGNEDTEXT retains its arc, alignment and spacing parameters. Saved glyph positions and proxy transform matrices are used when present; otherwise the renderer lays characters out along the arc using the available font metrics.

PDFUNDERLAY, DGNUNDERLAY, and DWFUNDERLAY, together with their corresponding definition objects, are imported as UnderlayReference and UnderlayDefinition. Page/model/sheet names, paths, placement, scaling, rotation, clipping, visibility, monochrome, contrast and fade are retained. Missing or undecoded external content has a selectable reference frame and an import diagnostic in the application log.

External document decoding is not bundled. Set RenSLPanel.UnderlayRenderer before opening a drawing to supply a PDF, DGN, or DWF decoder. The callback receives the definition and resolved source path and returns an UnderlayRaster containing a bitmap and the page width/height in drawing units before reference scaling. RenSL owns and disposes the returned bitmap, caches the texture per document and sheet, applies display adjustments, and places and clips it in the drawing. The callback may run on an import worker and must be thread-safe.

DXF Object Model

In addition to file import, RenSL exposes an object model that allows direct access to DXF entities. This makes it suitable not only for rendering, but also for inspection, transformation, and custom CAD-related workflows.

WinForms Renderer Control

RenSL includes a WinForms control that acts as a 3D renderer. It is designed to be simple to host inside a standard WinForms application and provides fast rendering performance using a CPU-based pipeline.

Barebones Example

Once the renderer control has been added to your WinForms form in the designer, a DXF file can be loaded and displayed with minimal setup.

using System;
using System.Windows.Forms;

namespace RenSL.Example
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
            // Example: load and display a DXF file
            rendererControl1.LoadFile(@"C:\Models\example.dxf");
        }
    }
}