Right-Click Select This is a read-only archive
← All ideas
  • Published 11 Nov 2021

A Scalable Vector Renderer In Blender

VERTEX_DRAWING_0.png VERTEX-Based

To increase Cycles render performance, is it possible to implement an SVG engine, as seen in HTML 5 -- but for 3D?

Regions could be extruded and or deformed as 3D paths, regions, and shapes, similar to extruding a mountain terrain. And Height-map and or geo-spatial coordinate information could be encoded as color.

Or MULTIPLE SVG Aspects of a mesh could be stored in memory. From four (4) different perspectives. And with the use of software, the resultant 3D mesh is inferred , for later rendering as a rasterized or raytraced image.
VERTEX_DRAWING_1.png SVG-Based

33.3%

Development Status: Open

Upvote 1 Downvote 2
ahsmassachusetts
11 Nov 2021

2 Comments

koko_ze

For grease pencil stuff?

1
ahsmassachusetts Author

Sure!

The SVG specification will need to be extended for our needs to support, BLENDABLE REGIONS, DITHER-ABLE PATHS & STROKES, MUTABLE REGIONS, 3D Surface (raytrace support)... and a number of other new properties to fully show off its superior fast-rendering performance.

Here is a cursory proof that SVG-based renderers should have better performance versus traditional vertex renderers

'''---------------------------------------------------------------------------------------- AUTHOR : AHSMASSACHUSETTS

DESCRIPTION : Z3Prover is a propositional logic theorem prover developed in Python which tests a statements' consistency and SATISFIABILITY This library will be used to validate the suitability (satisfiability) of Scalable Vector Graphics in lieu of Vertex-based renderers

Proof : SVG => ARE_SUPERIOR_RENDER_OBJECTS( SVG ) && Not( ARE_BANDWIDTH_CONSTRAINED_RENDERS( SVG ) )

----------------------------------------------------------------------------------------'''

import z3

Or = z3.Or

And = z3.And

Not = z3.Not

Bool = z3.Bool

Const = z3.Const

Solver = z3.Solver

Implies = z3.Implies

Function = z3.Function

BoolSort = z3.BoolSort

DeclareSort = z3.DeclareSort

Object = DeclareSort('Object')

SVG = Const('SVG', Object)

VERTEX_MESHES = Const('VERTEX_MESHES', Object)

ARE_SCALABLE = Function('ARE_SCALABLE', Object, BoolSort())

ARE_RAYTRACEABLE = Function('ARE_RAYTRACEABLE', Object, BoolSort())

CAN_BE_RASTERIZED = Function('CAN_BE_RASTERIZED', Object, BoolSort())

ARE_BANDWIDTH_CONSTRAINED_RENDERS = Function('ARE_BANDWIDTH_CONSTRAINED_RENDERS', Object, BoolSort())

CAN_BE_SCALED_EFFICIENTLY = Function('CAN_BE_SCALED_EFFICIENTLY', Object, BoolSort())

CONTAIN_ONE_OR_MORE_GROUPED_REGIONS = Function('CONTAIN_ONE_OR_MORE_GROUPED_REGIONS', Object, BoolSort())

ARE_SUPERIOR_RENDER_OBJECTS = Bool('ARE_SUPERIOR_RENDER_OBJECTS')

proof = Solver()

proof.add( And( ARE_SCALABLE( SVG ), Not( ARE_SCALABLE( VERTEX_MESHES ) ) ) )

proof.add( And( ARE_RAYTRACEABLE( VERTEX_MESHES ), ARE_RAYTRACEABLE( SVG ) ) )

proof.add( And( CAN_BE_RASTERIZED( VERTEX_MESHES ), CAN_BE_RASTERIZED( SVG ) ) )

proof.add( And( CONTAIN_ONE_OR_MORE_GROUPED_REGIONS( VERTEX_MESHES ), CONTAIN_ONE_OR_MORE_GROUPED_REGIONS( SVG ) ) )

proof.add( Implies( ARE_SUPERIOR_RENDER_OBJECTS, And( ARE_BANDWIDTH_CONSTRAINED_RENDERS( VERTEX_MESHES ), Not( ARE_BANDWIDTH_CONSTRAINED_RENDERS( SVG ) ) ) ) ))

proof.check() # sat!

print( f" { proof.model } " )