ezii 0.0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dcc661b39e7792d0581ee923e7f8d1f7de366581
-  data.tar.gz: a89c46f411e06ca657505ae746f9a590381d125c
+SHA256:
+  metadata.gz: 04cc97a422d1ad21da0334fd1f5e7be4139e6f8b9e48b413be66d06c3dd0bb35
+  data.tar.gz: b32a4caeb05e6bfa31d640fba5318123dc9fa020e07a6869cdd2697b4658a362
 SHA512:
-  metadata.gz: 8253dd1953193e65c05c4cee81151bb1e482868c9b8755add2dcc7348937cc4d7fd8fbe89e26c96a940bf7e88025bfa20ecf998ec74b2f7a8c8236cff35c3457
-  data.tar.gz: 8079e01e22feed0dc898709a036445829274cb422c58f84a7293cf75fcd8f0c7c33bff59d3032348faade07fb51270c5ddd5d522afd376d098fc22bfaa10656e
+  metadata.gz: 98c7347c85fde99a3d315946f08688db27a33bedffd7cec293af21ff021a4502698f5a74ebcec1caefd1cddbc5bca7aa2799cffdd81d012f6529a4a82c23e2a4
+  data.tar.gz: b173ebd5dab2902fa8a67c33d5f061224082c2b8a138efe907240becfe28418b7dcdc2544f06eecc7af37510de8737fa64d08be2c3152aaf8e17685db6412f4b

data/eezee-3-aka-game-x-engine/README.md

@@ -0,0 +1,5 @@
+[![Gitter](https://badges.gitter.im/qanda-api/Lobby.svg)](https://gitter.im/qanda-api/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+# gam
+
+Game Aided Manufacturing

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/functions/base_command.rb

@@ -0,0 +1,20 @@
+
+class BaseCommand
+    def initialize(gam_main_instance)
+        @active = true
+        @gam_main_instance = gam_main_instance
+    end
+
+    def active?
+        @active
+    end
+
+    def finish
+    end
+
+    def mouse_down(vector)
+    end
+
+    def mouse_up(vector)
+    end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/functions/mouse_y_axis_to_3d_z_axis.rb

@@ -0,0 +1,4 @@
+require_relative './base_command.rb'
+
+class MouseYAxisTo3dZAxis < BaseCommand
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/functions/rotate_camera_axis_using_mouse_drag.rb

@@ -0,0 +1,37 @@
+
+class RotateCameraAxisUsingMouseDrag
+    def initialize(gam_main_instance)
+        @active = true
+        @gam_main_instance = gam_main_instance
+    end
+
+    def active?
+        @active
+    end
+
+    def finish
+        @active = false
+    end
+
+    def mouse_down(vector)
+        @mouse_down = true
+    end
+
+    def mouse_move(vector)
+        unless @last_point.nil?
+            difference_vector = @last_point.sub(vector)
+
+            @gam_main_instance.camera.rotation.x += difference_vector.x
+            @gam_main_instance.camera.rotation.y += difference_vector.y
+        end
+
+        if @mouse_down
+            @last_point = vector
+        end
+    end
+
+    def mouse_up(vector)
+        @mouse_down = false
+        finish
+    end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/functions/selection_cube.rb

@@ -0,0 +1,35 @@
+require_relative '../shapes/cube'
+
+class SelectionCube
+    def initialize(gam_main_instance)
+        @active = true
+        @gam_main_instance = gam_main_instance
+    end
+
+    def active?
+        @active
+    end
+
+    def finish
+        @active = false
+
+        difference_vector = @second_point.sub(@first_point)
+
+        z_size = 2 # unsure how to tackle z size for now, so i'll set it to a default 2 until i found a better solution, then it would be `difference_vector.z.abs`
+        size_vector = Mittsu::Vector3.new(difference_vector.x.abs, difference_vector.y.abs, z_size)
+
+        
+        @selection_cube = Cube.new(size_vector: size_vector)
+        @selection_cube.position = @first_point
+        @gam_main_instance.scene.add(@selection_cube.mittsu_object)
+    end
+
+    def mouse_down(vector)
+        @first_point = vector
+    end
+
+    def mouse_up(vector)
+        @second_point = vector
+        self.finish
+    end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/gam.rb

@@ -0,0 +1,467 @@
+require 'mittsu'
+require_relative 'shapes/cube.rb'
+require 'pry-remote'
+require 'ast'
+require 'byebug'
+
+# Monkey patching Object like it's the golden old days
+
+class Object
+  def recursive_find(method_name, &find_condition_block)
+    if find_condition_block.call(self)
+      return self
+    end
+
+    if self.respond_to?(method_name)
+      enumerable = self.public_send(method_name)
+    elsif self.respond_to?(:each)
+      enumerable = self.each
+    else
+      return nil
+    end
+
+    enumerable.each do |item|
+      result = item.recursive_find(method_name, &find_condition_block)
+
+      if not result.nil?
+        return result
+      end
+    end
+
+    return nil
+  end
+end
+
+class PlayedCommands
+  def initialize
+    @played_commands = []
+  end
+
+  def played_commands
+    @played_commands
+  end
+
+  def any?
+    @played_commands.any?
+  end
+
+  def last
+    @played_commands.last
+  end
+
+  def push(command)
+    @played_commands.push(command)
+  end
+end
+
+class FunctionWrapper
+  attr_accessor :function_class, :file_path
+  def initialize(file_path)
+    @file_path = file_path
+    @abstract_syntax_tree = RubyVM::AbstractSyntaxTree
+      .parse_file(file_path)
+
+    get_command_class_name
+  end
+
+  def get_command_class_name
+    # if class is deeper than first level, let's invent Enumerable#recursive_find
+    @command_class_node = @abstract_syntax_tree.recursive_find(:children) do |child|
+      child.class == RubyVM::AbstractSyntaxTree::Node && child.type == :CLASS
+    end
+
+    @command_class_name = @command_class_node
+      .children
+      .first
+      .pretty_print_inspect
+      .match(/:(\w+)\)\Z/)[1]
+  end
+
+  def new_command_instance(gam_main_instance)
+    load(@file_path)
+
+    # SEC-TODO: fix eval, especially when considering downloadable functions
+    command_instance = eval(@command_class_name).new(gam_main_instance)
+
+    return command_instance
+  end
+
+  def command_class_name
+    @command_class_name
+  end
+end
+
+class Gam
+  SELECTED_CUBE_COLOR = 0xf4e842
+  RED = 0xf441dc
+
+  # TODO: cubes array needds to be eliminated
+  CUBES = []
+  attr_accessor :functions, :key_map, :scene, :camera
+
+  def cubes
+    CUBES
+  end
+
+  def initialize
+    self.functions = []
+    self.key_map = {}
+    @played_commands = PlayedCommands.new
+    load_local_functions
+
+    legacy_initialize
+  end
+
+  def played_commands
+    @played_commands
+  end
+
+  def execute_command(command_wrapper)
+    played_commands.push(command_wrapper.new_command_instance(self))
+  end
+
+  def active_command(&block)
+    if played_commands.any? && played_commands.last.active?
+      block.call(played_commands.last)
+    end
+  end
+
+  def forever
+    sleep 1
+    while true; yield; end
+  end
+
+  def legacy_initialize
+    @cube_index = 0
+
+    @screen_width = 800
+    @screen_height = 600
+    aspect = @screen_width.to_f / @screen_height
+
+    @renderer = Mittsu::OpenGLRenderer.new(
+      width: @screen_width,
+      height: @screen_height,
+      title: 'TOOLX'
+    )
+
+    @scene = Mittsu::Scene.new
+
+    @camera = Mittsu::PerspectiveCamera.new(75.0, aspect, 0.1, 1000.0)
+    @camera.position.z = 5.0
+
+    @plane = Mittsu::Mesh.new(
+      Mittsu::BoxGeometry.new(1.0, 10.0, 10.0),
+      Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
+    )
+
+    @scene.add(@plane)
+
+    waiting_for_w_console_command = false
+
+    console_function = -> {
+      unless waiting_for_w_console_command
+        waiting_for_w_console_command = true
+        puts 'Enter ruby code that will be evaluated in the current session:'
+
+        user_input = gets
+        puts "Running code u entered #{user_input}"
+        eval(user_input)
+        waiting_for_w_console_command = false
+      end
+    }
+
+    previously_selected_cube_color = nil
+    @renderer.window.on_key_typed do |key|
+      case key
+      when GLFW_KEY_A
+        @plane.rotation.x += 0.5
+      when GLFW_KEY_B
+        @plane.rotation.y += 0.5
+      when GLFW_KEY_C
+        @plane.rotation.x -= 0.5
+      when GLFW_KEY_D
+        @plane.rotation.y -= 0.1
+      when GLFW_KEY_E
+        @camera.position.x -= 0.1
+      when GLFW_KEY_F
+        @camera.position.y -= 0.1
+      when GLFW_KEY_G
+        @camera.position.z -= 0.1
+      when GLFW_KEY_H
+        @camera.position.x += 0.1
+      when GLFW_KEY_I
+        @camera.position.y += 0.1
+      when GLFW_KEY_J
+        @camera.position.z += 0.1
+      when GLFW_KEY_K
+        @scene.add(Cube.new(color: 0x42e5f4).mittsu_object)
+      when GLFW_KEY_L
+        @scene.add(Cube.new(color: 0xf44941).mittsu_object)
+      when GLFW_KEY_M
+        @scene.add(Cube.new(color: 0xf441dc).mittsu_object)
+      when GLFW_KEY_N
+        CUBES[@cube_index].position.x += 0.1
+      when GLFW_KEY_O
+        CUBES[@cube_index].position.x -= 0.1
+      when GLFW_KEY_P
+        CUBES[@cube_index].position.y += 0.1
+      when GLFW_KEY_R
+        CUBES[@cube_index].position.y -= 0.1
+      when GLFW_KEY_S
+        CUBES[@cube_index].material.color.set_hex(previously_selected_cube_color) if previously_selected_cube_color != nil
+        @cube_index += 1
+        if @cube_index == CUBES.length
+          @cube_index = 0
+        end
+        previously_selected_cube_color = CUBES[@cube_index].material.color.hex
+        CUBES[@cube_index].material.color.set_hex(SELECTED_CUBE_COLOR)
+      when GLFW_KEY_T
+        CUBES[@cube_index].material.color.set_hex(previously_selected_cube_color)  if previously_selected_cube_color != nil
+        @cube_index -= 1
+        if @cube_index == -1
+          @cube_index = [CUBES.length - 1, 0].min
+        end
+        previously_selected_cube_color = CUBES[@cube_index].material.color.hex
+        CUBES[@cube_index].material.color.set_hex(SELECTED_CUBE_COLOR)
+      when GLFW_KEY_U
+        @scene.remove(@plane)
+      when GLFW_KEY_V
+        @scene.add(@plane)
+      when GLFW_KEY_W
+        CUBES.sample.fall_down 
+
+        # while true
+          # forever { CUBES.sample.fall_down }
+
+          # sleep 0.002
+
+          # CUBES.sample.fall_down
+        # end
+
+        @cube_fall_down = true
+
+        # byebug
+        # instance_exec(&console_function)
+      when GLFW_KEY_X
+        print_local_functions
+      when GLFW_KEY_Y
+        remap_functions
+      when GLFW_KEY_Z
+        # binding.remote_pry
+
+        self.execute_command(self.key_map['z'])
+        # print_remote_functions
+      end
+    end
+
+    @renderer.window.on_resize do |width, height|
+      on_resize(width, height)
+    end
+
+    raycaster = Mittsu::Raycaster.new
+
+    object_being_moved_by_mouse = nil
+
+    previously_selected_cube_color_1 = nil
+    @renderer.window.on_mouse_button_pressed do |button, position|
+      click_to_world_var = mouse_position_to_3d_position(position)
+
+      active_command do |command|
+        command.mouse_down(click_to_world_var)
+      end
+
+      normalized = normalize_2d_screen_position(position)
+      raycaster.set_from_camera(normalized, @camera)
+      object_being_moved_by_mouse = raycaster
+                                    .intersect_objects(CUBES)
+                                    .map \
+                                      do |intersected_object_and_meta_information|
+                                        intersected_object_and_meta_information[:object]
+                                      end
+                                    .first
+
+      if object_being_moved_by_mouse
+        previously_selected_cube_color_1 = object_being_moved_by_mouse.material.color
+        object_being_moved_by_mouse.material.color = SELECTED_CUBE_COLOR
+      end
+    end
+
+
+    @renderer.window.on_mouse_move do |position|
+      click_to_world_var = mouse_position_to_3d_position(position)
+
+      active_command do |command|
+        command.mouse_move(click_to_world_var)
+      end
+
+      unless object_being_moved_by_mouse.nil?
+        object_being_moved_by_mouse.position.x = click_to_world_var.x
+        object_being_moved_by_mouse.position.y = click_to_world_var.y
+      end
+    end
+
+    @renderer.window.on_mouse_button_released do |_button, position|
+      click_to_world_var = mouse_position_to_3d_position(position)
+
+      active_command do |command|
+        command.mouse_up(click_to_world_var)
+      end
+
+      unless object_being_moved_by_mouse.nil?
+        object_been_moved_by_mouse = object_being_moved_by_mouse
+        object_being_moved_by_mouse = nil
+
+
+        object_been_moved_by_mouse.position.x = click_to_world_var.x
+        object_been_moved_by_mouse.position.y = click_to_world_var.y
+
+        object_been_moved_by_mouse.material.color = previously_selected_cube_color_1
+      end
+    end
+
+    @renderer.window.on_scroll do |offset|
+      @camera.position.z += offset.y
+    end
+  end
+
+  def on_resize(width, height)
+    @screen_width = width
+    @screen_height = height
+
+    @renderer.width = width
+    @renderer.height = height
+
+    @camera.aspect = width.to_f / height
+    @camera.update_projection_matrix
+  end
+
+  def print_local_functions
+    p self.functions
+  end
+
+  def load_local_functions
+    Dir[File.dirname(__FILE__) + '/functions/*.rb'].each do |file_path|
+      functions.push(FunctionWrapper.new(file_path))
+    end
+  end
+
+  def normalize_2d_screen_position(position)
+    new_position = Mittsu::Vector2.new
+    new_position.x = (((position.x * 2)/@screen_width)*2.0-1.0)
+    new_position.y = (((position.y * 2)/@screen_height)*-2.0+1.0)
+    new_position
+  end
+
+  def screen_to_world(vector, camera)
+    vector.unproject(camera).sub(camera.position).normalize
+    distance = -camera.position.z / vector.z
+    vector.multiply_scalar(distance).add(camera.position)
+  end
+
+  def mouse_position_to_3d_position(position)
+    normalized = normalize_2d_screen_position(position)
+    normalized_3d = Mittsu::Vector3.new(
+      normalized.x,
+      normalized.y,
+      0 # object_been_moved_by_mouse.position.z
+    )
+
+    screen_to_world(normalized_3d, @camera)
+  end
+
+  def remap_functions
+    print_local_functions
+
+    p 'Enter index of unmapped function:'
+    index_of_unmapped_function = gets.to_i
+
+    p 'Enter key to map function to:'
+    keyboard_key = gets
+
+    keyboard_key.chomp!
+
+    key_map[keyboard_key] = functions[index_of_unmapped_function]
+  end
+
+  def start
+    ticks = 0
+    @renderer.window.run do
+      if @cube_fall_down
+        CUBES.sample.fall_down    
+      end
+
+      if !(     (cube = CUBES).sample.nil? || @plane.nil?     )
+        cube = TeZiiCube.new(cube)
+        plane = TeZiiCube.new(@plane)
+
+        fail if cube.intersects_with?(plane)
+
+        if @plane.position.y > CUBES.sample.position.y
+          ticks = 0 if ticks > 50
+          ticks += 1
+          # fail "whatever"
+          previous_color = @plane.material.color.hex
+
+          if ticks > 10
+            @plane.material.color.set_hex(0x00ff00)
+          else
+            @plane.material.color.set_hex(RED)
+          end
+        end
+      end
+
+      @renderer.render(@scene, @camera)
+    end
+  end
+end
+
+# T for Teamwork
+class TeZiiCube
+  attr_accessor :wrapped_3d_object
+
+  def size
+    [
+      # fail(self.wrapped_3d_object.instance_variable_get(:@geometry).instance_variable_get(:@parameters).inspect),
+      self.wrapped_3d_object.instance_variable_get(:@geometry).instance_variable_get(:@parameters)[:width].inspect,
+      self.wrapped_3d_object.instance_variable_get(:@geometry).instance_variable_get(:@parameters)[:height].inspect,
+      self.wrapped_3d_object.instance_variable_get(:@geometry).instance_variable_get(:@parameters)[:depth].inspect
+    ]
+   
+  end
+
+  def initialize(wrapped_3d_object)
+    @wrapped_3d_object = wrapped_3d_object
+  end
+
+  # type of argument: TeZiiCube
+  def intersects_with?(other_t_ezii_cube)
+    width = other_t_ezii_cube.size[0]
+
+    
+    height = other_t_ezii_cube.size[1]
+
+    depth = other_t_ezii_cube.size[2]
+
+    position = other_t_ezii_cube.instance_variable_get(:@wrapped_3d_object).position
+
+    width_self = self.size[0]
+    height_self = self.size[1]
+    depth_self = self.size[2]
+
+    position_self = self.instance_variable_get(:@wrapped_3d_object).position
+
+
+    condition_1 = position.x > self_position.x && position.y > self_position.y && position.z > self_position.z 
+    condition_2 = true
+    # condition_2 = position.y > self_position.x && position.y > self_position.y && position.z > self_position.z 
+    # condition_3
+    # condition_4
+    # condition_5
+    # condition_6
+    condition_7 = width > width_self && height > height_self && depth > depth_self
+
+    if condition_1 && condition_2 && condition_7
+      return true
+    end
+  end
+end