jenncad 1.0.0.pre.alpha1

data/lib/jenncad/primitives/rotate_extrude.rb

@@ -0,0 +1,20 @@
+module JennCad::Primitives
+  attr_accessor :convexity
+  class RotateExtrude < JennCad::Thing
+    def initialize(part, args)
+      @transformations = []
+      @parts = [part]
+      @angle = args[:angle]
+      @cut = args[:cut]
+      @fn = args[:fn]
+    end
+
+    def openscad_params
+      res = {}
+      [:cut, :angle, :convexity, :fn].each do |n|
+        res[n] = self.send n
+      end
+      res
+    end
+  end
+end

data/lib/jenncad/primitives/rounded_cube.rb

@@ -0,0 +1,77 @@
+module JennCad::Primitives
+  class RoundedCube < Primitive
+    attr_accessor :d, :r
+
+    def initialize(args)
+      if args.kind_of?(Array) && args[0].kind_of?(Hash)
+        args = args.first
+      end
+      if args.kind_of? Array
+        m = {}
+        if args.last.kind_of? Hash
+          m = args.last
+        end
+        args = [:x, :y, :z, :d].zip(args.flatten).to_h.compact
+        args.deep_merge!(m)
+      end
+
+      @opts = {
+        d: 5,
+        x: 0,
+        y: 0,
+        z: nil,
+        r: nil,
+        flat_edges: nil,
+        margins: {
+          r: 0,
+          d: 0,
+          x: 0,
+          y: 0,
+          z: 0,
+        },
+      }.deep_merge!(args)
+      handle_margins
+      handle_diameter
+      super(opts)
+    end
+
+    def to_openscad
+      return cube(@opts) if @d == 0
+      # make diameter not bigger than any side
+      @d = [@d, @x, @y].min
+      res = HullObject.new(
+        cylinder(d:@d, h:@z).moveh(x: -@x + @d, y: @y - @d),
+        cylinder(d:@d).moveh(x: @x - @d, y: @y - @d),
+        cylinder(d:@d).moveh(x: -@x + @d, y: -@y + @d),
+        cylinder(d:@d).moveh(x: @x - @d, y: -@y + @d),
+      )
+
+      if @opts[:flat_edges]
+        if @opts[:flat_edges].kind_of?(Array)
+          @opts[:flat_edges].each do |e|
+            res += flat_edge(e)
+          end
+        else
+          res += flat_edge(@opts[:flat_edges])
+        end
+      end
+
+      res.transformations = @transformations
+      res
+    end
+
+    def flat_edge(edge)
+      case edge
+      when :up
+        cube(@x, @y/2.0, @z).moveh(y:@y/2.0)
+      when :down
+        cube(@x, @y/2.0, @z).moveh(y:-@y/2.0)
+      when :right
+        cube(@x/2.0, @y, @z).moveh(x:@x/2.0)
+      when :left
+        cube(@x/2.0, @y, @z).moveh(x:-@x/2.0)
+      end
+    end
+
+  end
+end

data/lib/jenncad/primitives/slot.rb

@@ -0,0 +1,82 @@
+module JennCad::Primitives
+  class Slot < Primitive
+    attr_accessor :d, :r, :h, :fn, :len_x, :len_y
+
+    def initialize(args)
+      if args.kind_of?(Array) && args[0].kind_of?(Hash)
+        args = args.first
+      end
+      if args.kind_of? Array
+        m = {}
+        if args.last.kind_of? Hash
+          m = args.last
+        end
+        args = [:d, :z].zip(args.flatten).to_h
+        args.deep_merge!(m)
+      end
+
+      args[:z] ||= args[:h]
+
+      @opts = {
+        d: 0,
+        a: 0,
+        z: nil,
+        r: nil,
+        x: 0,
+        y: 0,
+        margins: {
+          r: 0,
+          d: 0,
+          z: 0,
+        },
+      }.deep_merge!(args)
+
+      super(opts)
+
+      @d = @opts[:d]
+      @a = @opts[:a]
+      @h = @opts[:h]
+      @r = @opts[:r]
+      @fn = @opts[:fn]
+      @len_x = @opts[:x]
+      @len_y = @opts[:y]
+    end
+
+    def to_openscad
+      c1 = cylinder(@opts)
+      c2 = cylinder(@opts)
+      if @len_x
+        c2.move(x:@len_x)
+      end
+      if @len_y
+        c2.move(y:@len_y)
+      end
+      res = c1 & c2
+      if @a != 0.0
+        res = res.rotate(z:@a)
+      end
+      if @transformations && @transformations.size > 0
+        res = UnionObject.new([res])
+        res.transformations = @transformations
+        return res
+      end
+      res
+    end
+
+    def end_vector
+      if @a.to_f == 0.0
+        return [@len_x, 0] if @len_x
+        return [0, @len_y] if @len_y
+      end
+      if @len_x
+        x = cos(PI*@a/180.0)*@len_x.to_f
+        y = sin(PI*@a/180.0)*@len_x.to_f
+      else
+        x = -1* sin(PI*@a/180.0)*@len_y.to_f
+        y = cos(PI*@a/180.0)*@len_y.to_f
+      end
+      [x,y]
+    end
+
+  end
+end

data/lib/jenncad/primitives/sphere.rb

@@ -0,0 +1,11 @@
+module JennCad::Primitives
+  class Sphere < Primitive
+    attr_accessor :d, :r, :fn
+    def initialize(args)
+      super
+      @d = args[:d]
+      @r = args[:r]
+      @fn = args[:fn]
+    end
+  end
+end

data/lib/jenncad/primitives/subtract_object.rb

@@ -0,0 +1,84 @@
+module JennCad::Primitives
+  class SubtractObject < BooleanObject
+    def inherit_z
+      @z = 0
+      @calc_z = parts.first.calc_z.to_f
+      only_additives_of(@parts).each do |p|
+        z = p.z.to_f
+        @z = z if z > @z
+      end
+    end
+
+    def get_heights(obj)
+      res = []
+      obj.each do |part|
+        if part.respond_to? :calc_h
+          res << part.calc_h
+        end
+      end
+      res
+    end
+
+    def get_z(obj)
+      res = []
+      obj.each do |part|
+        if part.respond_to? :calc_z
+          res << part.calc_z
+        end
+      end
+      res
+    end
+
+    def analyze_z_fighting
+      first = get_primitives(@parts.first).flatten
+      others = get_primitives(@parts[1..-1]).flatten
+
+      first_h = get_heights(first).uniq
+      first_z = get_z(first).uniq
+      #puts first.inspect
+      if first_h.size > 1
+#        puts "first item has multiple heights: #{first_h.inspect}"
+        first_h.each do |h|
+          compare_z(others, h, first_z.first)
+        end
+      else
+        compare_z(others, first_h.first, first_z.first)
+      end
+    end
+
+    # FIXME
+    # this won't work reliable with Aggregations at the moment;
+    # they don't have calc_z for comparing with the top
+    # and it will try to move the Aggregation which it should not do
+    # (it should move the calls to the Aggregation, not the Aggregation itself)
+    def compare_z(others,compare_h,compare_z)
+      others.each do |part|
+        #puts part.inspect
+        #puts "#{part.calc_z+part.calc_h} ; #{compare_h}"
+        if part.respond_to? :z
+          if part.referenced_z && part.z != 0.0
+            case part
+            when JennCad::BooleanObject
+            else
+              part.z+=0.2
+              part.translate(z:-0.1)
+            end
+          elsif part.z == compare_h
+#            puts "fixing possible z fighting: #{part.class} #{part.z}"
+            part.z+=0.008
+            part.translate(z:-0.004)
+          elsif part.calc_z == compare_z
+#            puts "z fighting at bottom: #{part.calc_z}"
+            part.z+=0.004
+            part.translate(z:-0.002)
+          elsif part.calc_z.to_f+part.calc_h.to_f == compare_h
+#            puts "z fighting at top: #{compare_h}"
+            part.z+=0.004
+            part.translate(z:0.002)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/jenncad/primitives/union_object.rb

@@ -0,0 +1,5 @@
+module JennCad::Primitives
+  class UnionObject < BooleanObject
+
+  end
+end

data/lib/jenncad/profile_loader.rb

@@ -0,0 +1,34 @@
+module JennCad
+  class ProfileLoader
+    def initialize
+      load_profile
+    end
+
+    def profile_dir
+      File.expand_path(["~", ".config", "jenncad"].join("/"))
+    end
+
+    def profile_path
+      [profile_dir, "profile.rb"].join("/")
+    end
+
+    def load_profile
+      if File.exists?(profile_path)
+        require profile_path
+        check_profile
+      else
+        load_defaults
+      end
+    end
+
+    def check_profile
+      unless defined?($jenncad_profile)
+        load_defaults
+      end
+    end
+
+    def load_defaults
+      $jenncad_profile = JennCad::DefaultProfile.new
+    end
+  end
+end

data/lib/jenncad/project.rb

@@ -0,0 +1,28 @@
+module JennCad
+  class Project
+    def output_dir
+      "output"
+    end
+
+    def outputs
+      self.class.instance_methods(false) - [:config, :outputs, :output_dir]
+    end
+
+    def run
+      # load all files in subdirectories
+      Dir.glob("*/**/*.rb").each do |file|
+        require "./#{file}"
+      end
+      FileUtils.mkdir_p(output_dir)
+      run_exports
+    end
+
+    def run_exports
+      outputs.each do |name|
+        part = self.send(name)
+        part.openscad([output_dir,"#{name}.scad"].join("/"))
+      end
+    end
+
+  end
+end

data/lib/jenncad/register.rb

@@ -0,0 +1,31 @@
+module JennCad
+
+  class Register
+    def initialize
+      @counts = {}
+      @objects = {}
+    end
+
+    def register(cl, args)
+      if @objects[cl] == nil || @objects[cl][args] == nil
+        register_new(cl, args)
+      end
+      return @objects[cl][args]
+    end
+
+    def register_new(cl,args)
+       @counts[cl] ||= {}
+       @objects[cl] ||= {}
+       if  @counts[cl][args]
+         @counts[cl][args] += 1
+       else
+         @counts[cl][args] = 1
+       end
+
+       @objects[cl][args] = cl.send :new, args
+    end
+  end
+
+  $parts = Register.new
+
+end

data/lib/jenncad/shortcuts.rb

@@ -0,0 +1,109 @@
+module JennCad
+  def circle(args)
+    Circle.new(args)
+  end
+
+  def cylinder(*args)
+    Cylinder.new(args)
+  end
+  alias :cy :cylinder
+  alias :cyl :cylinder
+
+  def sphere(args)
+    Sphere.new(args)
+  end
+  alias :sp :sphere
+
+  def polygon(args)
+    Polygon.new(args)
+  end
+
+  def slot(*args)
+    Slot.new(args)
+  end
+
+  def cube(*args)
+    Cube.new(args)
+  end
+  alias :cu :cube
+
+  def rounded_cube(*args)
+    RoundedCube.new(args)
+  end
+  alias :rcube :rounded_cube
+  alias :rc :rounded_cube
+
+  # import/use OpenScad library
+  def import(import,name,args)
+    OpenScadImport.new(import, name, args)
+  end
+
+  def extrude(args)
+    LinearExtrude.new(self, args)
+  end
+
+  def rotate_extrude(args={})
+    RotateExtrude.new(self, args)
+  end
+
+  def to_2d(args={})
+    Projection.new(self, args)
+  end
+
+  def union(*args)
+    UnionObject.new(*args)
+  end
+
+  def +(args)
+    return args if self == nil
+    if self.kind_of?(UnionObject) && self.transformations.size == 0
+      self.add(args)
+      return self
+    else
+      UnionObject.new(self,args)
+    end
+  end
+
+  def subtraction(*args)
+    SubtractObject.new(*args)
+  end
+
+  def -(args)
+    if self.kind_of?(SubtractObject) && self.transformations.size == 0
+      self.add(args)
+      return self
+    else
+      SubtractObject.new(self,args)
+    end
+  end
+
+  def intersection(*args)
+    IntersectionObject.new(*args)
+  end
+
+  def *(args)
+    if self.kind_of?(IntersectionObject) && self.transformations.size == 0
+      self.add(args)
+      return self
+    else
+      IntersectionObject.new(self,args)
+    end
+  end
+
+  def hull(*args)
+    HullObject.new(*args)
+  end
+
+  def &(args)
+    if self.kind_of?(HullObject) && self.transformations.size == 0
+      self.add(args)
+      return self
+    else
+      HullObject.new(self,args)
+    end
+  end
+
+  def assemble(partlib=nil, z_skip = false, z=0, &block)
+    block.yield.assemble(partlib, z_skip, z)
+  end
+end