Merge pull request #19 from asinghvi17/as/protodocs

Prototype docs

Author: SimonDanisch

docs/make.jl

@@ -0,0 +1,30 @@
+#! /usr/bin/env julia
+
+using Documenter
+
+using GeometryBasics
+
+# Copy the README to serve as the homepage
+cp(joinpath(@__DIR__, "..", "README.md"), joinpath(@__DIR__, "src", "index.md"))
+
+makedocs(
+    format = Documenter.HTML(),
+    sitename = "GeometryBasics.jl",
+    pages = [
+        "index.md",
+        "primitives.md",
+        "rectangles.md",
+        "polygons.md",
+        "meshes.md",
+        "decomposition.md",
+        "distancefields.md",
+        "metadata.jl",
+        "api.md",
+    ],
+    modules = [GeometryTypes]
+)
+
+deploydocs(
+    repo = "github.com/JuliaGeometry/GeometryTypes.jl.git",
+    push_preview = true
+)

docs/src/api.md

@@ -0,0 +1,19 @@
+# API Reference
+
+## Exports
+
+```@autodocs
+Modules = [GeometryBasics]
+Order   = [:module, :constant, :type, :function, :macro]
+Public  = true
+Private = false
+```
+
+## Private
+
+```@autodocs
+Modules = [GeometryBasics]
+Order   = [:module, :constant, :type, :function, :macro]
+Public  = false
+Private = true
+```

docs/src/decomposition.md

@@ -0,0 +1,51 @@
+# Decomposition
+
+
+## Displaying primitives
+
+To display geometry primitives, they need to be decomposable.
+This can be done for any arbitrary primitive, by overloading the following interface:
+
+```julia
+# Let's take SimpleRectangle as an example:
+# Below is a minimal set of decomposable attributes to build up a triangle mesh:
+isdecomposable(::Type{T}, ::Type{HR}) where {T<:Point, HR<:SimpleRectangle} = true
+isdecomposable(::Type{T}, ::Type{HR}) where {T<:Face, HR<:SimpleRectangle} = true
+
+# This is an example implementation of `decompose` for points.
+function GeometryBasics.decompose(P::Type{Point{3, PT}}, r::SimpleRectangle, resolution=(2,2)) where PT
+    w,h = resolution
+    vec(
+        PT[
+            (x,y,0)
+            for x in range(r.x, stop = r.x+r.w, length = w),
+                y in range(r.y, stop = r.y+ r .h, length = h)
+        ]
+    )
+end
+
+function GeometryBasics.decompose(::Type{T}, r::SimpleRectangle, resolution=(2,2)) where T <: Face
+    w,h = resolution
+    Idx = LinearIndices(resolution)
+    faces = vec([Face{4, Int}(
+            Idx[i, j], Idx[i+1, j],
+            Idx[i+1, j+1], Idx[i, j+1]
+        ) for i=1:(w-1), j=1:(h-1)]
+    )
+    decompose(T, faces)
+end
+```
+
+With these methods defined, this constructor will magically work:
+
+```julia
+rect = SimpleRectangle(0, 0, 1, 1)
+m = GLNormalMesh(rect)
+vertices(m) == decompose(Point3f0, rect)
+
+faces(m) == decompose(GLTriangle, rect) # GLFace{3} == GLTriangle
+normals(m) # automatically calculated from mesh
+```
+
+As you can see, the normals are automatically calculated only with the faces and points.
+You can overwrite that behavior by also defining decompose for the `Normal` type!

docs/src/distancefields.md

@@ -0,0 +1 @@
+# Distance Fields

docs/src/implementation.md

@@ -0,0 +1,5 @@
+# Implementation
+
+In the backend, GeometryTypes relies on fixed-size arrays, specifically static vectors.
+
+TODO add more here.

docs/src/meshes.md

@@ -0,0 +1,12 @@
+# Meshes
+
+## Types
+
+```@docs
+AbstractMesh
+Mesh
+```
+
+## How to create a mesh
+
+### Meshing.jl

docs/src/metadata.md

@@ -0,0 +1 @@
+# Metadata

docs/src/polygons.md

@@ -0,0 +1 @@
+# Polygons

docs/src/primitives.md

@@ -0,0 +1,22 @@
+# Primitives
+
+## Points and Vectors
+
+## Simplices
+
+## Shapes
+
+```@docs
+Circle
+Sphere
+Cylinder
+```
+
+## Abstract types
+
+```@docs
+GeometryPrimitive
+AbstractSimplex
+AbstractMesh
+AbstractDistanceField
+```

docs/src/rectangles.md

@@ -0,0 +1 @@
+# Rectangles