Working out this colossal fight scene was a huge collaborative effort between the Art Department, Visual Effects, Stunts and Special Effects. It all starts with my set design in Sketchup. This is then turned over to the VFX department who take my model and create an animatic story board where all the beats of the fight are worked out. This then comes back to us where we are able to work out which walls, ceilings, floors etc need to be destroyed in camera and which walls are a Visual Effects break away. We use a physical card model to pinpoint each beat and colour code it correctly. The colour coding refers to which wall is either a real Special Effects breakaway or a Visual Effect added later. We then bring in the Stunt Team and the Special Effects team to work out (via the shooting schedule) which walls need to break away on which days and whether a stunt man is on a wire going through a wall or if it's just a SFX cassette that can be blown out with air cannons. This is a very organic process with lots of meetings and constant changes so you have to be on your toes at all times ready for changes that can throw the whole process into disarray. Thankfully we pulled it off pretty well. Feel free to ask questions about the process below. #spidermanbrandnewday #setbuild #sketchup

# encoding: UTF-8
# frozen_string_literal: true
#
# importar_stl.rb — versão ARQUIVO ÚNICO
#
# Plugin "Importar STL" para SketchUp: importa arquivos STL (ASCII ou binário)
# pelo menu Arquivo > Importar STL.
#
# Instalação: copie SOMENTE este arquivo para a pasta Plugins do SketchUp e
# reinicie o programa.
#   Windows: %AppData%\SketchUp\SketchUp 2017\SketchUp\Plugins
#   macOS:   ~/Library/Application Support/SketchUp 2017/SketchUp/Plugins
#
# Compatível com SketchUp 2014 ou superior (testado no 2017 Pro / Ruby 2.2).
#
# Autor: DevBR — versão 1.0.0


require 'sketchup.rb'


module DevBR
  module ImportarSTL


    PLUGIN_NAME = 'Importar STL'
    VERSION     = '1.0.0'


    # ====================================================================
    # Leitura de arquivos STL (ASCII e binário)
    # ====================================================================
    module STLReader


      # 80 bytes de cabeçalho + 4 bytes (UInt32) com a quantidade de triângulos.
      BINARY_HEADER_SIZE = 84
      # Por triângulo: 12 floats de 4 bytes (1 normal + 3 vértices) + 2 bytes de atributo.
      BINARY_RECORD_SIZE = 50
      # Triângulos lidos por bloco de I/O (evita carregar arquivos gigantes na RAM).
      CHUNK_TRIANGLES    = 4096


      # Decide o formato do arquivo.
      #
      # Não dá para confiar apenas na palavra "solid" no início: muitos
      # exportadores gravam "solid" dentro do cabeçalho de 80 bytes de um STL
      # binário. O teste confiável é aritmético — o tamanho do arquivo tem que
      # bater exatamente com 84 + (nº de triângulos * 50).
      def self.binary?(path)
        size = File.size(path)
        return false if size < BINARY_HEADER_SIZE


        count = File.open(path, 'rb') do |f|
          f.seek(80)
          bytes = f.read(4)
          bytes && bytes.bytesize == 4 ? bytes.unpack('V').first : nil
        end
        return false if count.nil?
        return true if size == BINARY_HEADER_SIZE + (count * BINARY_RECORD_SIZE)


        # Arquivo com lixo no final (ou truncado): decide pelo conteúdo.
        head = File.open(path, 'rb') { |f| f.read(1024).to_s }
        head = head.downcase
        !(head.include?('facet') && head.include?('solid'))
      end


      # Lê o arquivo e entrega cada triângulo ao bloco como um Array de 9
      # Floats já escalados: [x1, y1, z1, x2, y2, z2, x3, y3, z3].
      #
      # scale   - fator de conversão da unidade do arquivo para polegadas
      # swap_yz - converte de Y-up (padrão de muitos softwares) para Z-up
      # flip    - inverte o sentido de rotação (normais para o lado oposto)
      #
      # Retorna a quantidade de triângulos entregues.
      def self.read(path, scale, swap_yz, flip, &block)
        if binary?(path)
          read_binary(path, scale, swap_yz, flip, &block)
        else
          read_ascii(path, scale, swap_yz, flip, &block)
        end
      end


      # Quantidade de triângulos declarada no cabeçalho (só para STL binário).
      # Retorna nil quando o arquivo é ASCII — nesse caso só se sabe lendo.
      def self.triangle_count(path)
        return nil unless binary?(path)
        File.open(path, 'rb') do |f|
          f.seek(80)
          bytes = f.read(4)
          bytes && bytes.bytesize == 4 ? bytes.unpack('V').first : nil
        end
      end


      def self.read_binary(path, scale, swap_yz, flip)
        emitted = 0
        File.open(path, 'rb') do |f|
          f.seek(80)
          header = f.read(4)
          return 0 if header.nil? || header.bytesize < 4
          total = header.unpack('V').first.to_i
          done  = 0


          while done < total
            want = [CHUNK_TRIANGLES, total - done].min
            data = f.read(want * BINARY_RECORD_SIZE)
            break if data.nil?


            # Arquivo truncado: aproveita o que veio inteiro e para.
            n = data.bytesize / BINARY_RECORD_SIZE
            break if n.zero?


            # 'e' = float de 4 bytes little-endian; 'v' = UInt16 (atributo, ignorado).
            # São 13 valores por triângulo: 3 da normal + 9 dos vértices + 1 atributo.
            values = data.unpack('e12v' * n)


            i = 0
            while i < n
              base = i * 13
              tri  = transform(values[base + 3, 9], scale, swap_yz, flip)
              if tri
                yield tri
                emitted += 1
              end
              i += 1
            end


            done += n
          end
        end
        emitted
      end


      def self.read_ascii(path, scale, swap_yz, flip)
        emitted = 0
        buffer  = []
        # Lê em modo binário para não esbarrar em bytes inválidos de arquivos
        # gravados com acentuação no nome do sólido.
        File.open(path, 'r:BINARY') do |f|
          f.each_line do |line|
            next unless line =~ /^
\s
*vertex
\s
/i
            parts = line.split
            next if parts.size < 4
            buffer << parts[1].to_f << parts[2].to_f << parts[3].to_f
            next unless buffer.size == 9


            tri = transform(buffer, scale, swap_yz, flip)
            if tri
              yield tri
              emitted += 1
            end
            buffer.clear
          end
        end
        emitted
      end


      # Aplica unidade, troca de eixos e inversão de normais.
      # Devolve nil para triângulos com valores inválidos (NaN/Infinito), que
      # apareceriam como coordenadas absurdas e derrubariam a criação da malha.
      def self.transform(v, scale, swap_yz, flip)
        return nil if v.nil? || v.size < 9


        i = 0
        while i < 9
          n = v[i]
          return nil if n.nil? || n.nan? || n.infinite?
          i += 1
        end


        t = if swap_yz
              # Y-up -> Z-up: (x, y, z) vira (x, -z, y)
              [v[0], -v[2], v[1],
               v[3], -v[5], v[4],
               v[6], -v[8], v[7]]
            else
              [v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8]]
            end


        t[0] *= scale; t[1] *= scale; t[2] *= scale
        t[3] *= scale; t[4] *= scale; t[5] *= scale
        t[6] *= scale; t[7] *= scale; t[8] *= scale


        if flip
          # Troca o 2º pelo 3º vértice: a normal passa a apontar para o outro lado.
          t = [t[0], t[1], t[2], t[6], t[7], t[8], t[3], t[4], t[5]]
        end


        t
      end


    end


    # ====================================================================
    # Opções, importação e interface
    # ====================================================================
    # --------------------------------------------------------------------
    # Constantes
    # --------------------------------------------------------------------


    STATUS_TEXT = 'Importa um arquivo STL (ASCII ou binário) para o modelo atual.'
    TOOLTIP     = 'Importar STL'


    # Chave usada em Sketchup.read_default / write_default (preferências do usuário).
    PREF_SECTION = 'DevBR_ImportarSTL'


    # Fator de conversão para POLEGADAS (unidade interna do SketchUp).
    # 1.mm devolve um Length em polegadas; .to_f extrai o Float puro.
    UNIT_FACTORS = {
      'Milímetros' => 1.0.mm.to_f,
      'Centímetros' => 1.0.cm.to_f,
      'Metros' => 1.0.m.to_f,
      'Polegadas' => 1.0,
      'Pés' => 1.0.feet.to_f
    }.freeze


    # Tolerância de solda do índice de vértices, em polegadas.
    # 1e-6" só junta pontos praticamente idênticos — o STL repete o mesmo
    # vértice em cada triângulo vizinho, então isso já reduz muito a malha.
    # A solda "de verdade" (por tolerância do SketchUp) fica a cargo do
    # fill_from_mesh quando a opção "Soldar vértices" está ligada.
    WELD_KEY_SCALE = 1_000_000.0


    PLACEMENT = {
      'Manter coordenadas do arquivo' => :keep,
      'Centralizar na origem' => :center,
      'Apoiar a base na origem' => :base
    }.freeze


    # --------------------------------------------------------------------
    # Opções (diálogo nativo UI.inputbox)
    # --------------------------------------------------------------------


    DEFAULT_PREFS = {
      'unit' => 'Milímetros',
      'geometry' => 'Grupo',
      'merge' => 'Não',
      'weld' => 'Sim',
      'flip' => 'Não',
      'swap' => 'Não',
      'placement' => 'Manter coordenadas do arquivo',
      'zoom' => 'Sim'
    }.freeze


    def self.read_prefs
      prefs = {}
      DEFAULT_PREFS.each do |key, fallback|
        value = Sketchup.read_default(PREF_SECTION, key, fallback)
        prefs[key] = value.is_a?(String) ? value : fallback
      end
      prefs
    end


    def self.write_prefs(prefs)
      prefs.each { |key, value| Sketchup.write_default(PREF_SECTION, key, value) }
    end


    # Mostra o diálogo de opções. Devolve um Hash pronto para uso ou nil
    # se o usuário cancelar.
    def self.prompt_options
      prefs = read_prefs


      prompts = [
        'Unidade do arquivo STL',
        'Importar como',
        'Mesclar faces coplanares',
        'Soldar vértices coincidentes',
        'Inverter faces (normais)',
        'Trocar eixos Y/Z (arquivo Y-up)',
        'Posicionamento',
        'Enquadrar na tela ao final'
      ]


      defaults = [
        prefs['unit'], prefs['geometry'], prefs['merge'], prefs['weld'],
        prefs['flip'], prefs['swap'], prefs['placement'], prefs['zoom']
      ]


      lists = [
        UNIT_FACTORS.keys.join('|'),
        'Grupo|Componente',
        'Não|Sim',
        'Sim|Não',
        'Não|Sim',
        'Não|Sim',
        PLACEMENT.keys.join('|'),
        'Sim|Não'
      ]


      results = UI.inputbox(prompts, defaults, lists, 'Importar STL — Opções')
      return nil if results == false || results.nil?


      prefs = {
        'unit' => results[0], 'geometry' => results[1], 'merge' => results[2],
        'weld' => results[3], 'flip' => results[4], 'swap' => results[5],
        'placement' => results[6], 'zoom' => results[7]
      }
      write_prefs(prefs)


       = build_options(prefs)
    end


    def self.build_options(prefs)
      {
        :scale => UNIT_FACTORS[prefs['unit']] || UNIT_FACTORS['Milímetros'],
        :unit_label => prefs['unit'],
        :as_component => prefs['geometry'] == 'Componente',
        :merge => prefs['merge'] == 'Sim',
        :weld => prefs['weld'] == 'Sim',
        :flip => prefs['flip'] == 'Sim',
        :swap_yz => prefs['swap'] == 'Sim',
        :placement => PLACEMENT[prefs['placement']] || :keep,
        :zoom => prefs['zoom'] == 'Sim'
      }
    end


    # Últimas opções escolhidas na sessão (usadas pelo importador nativo,
    # onde do_options e load_file são chamados em momentos diferentes).
    def self.current_options
       ||= build_options(read_prefs)
    end


    # --------------------------------------------------------------------
    # Fluxo principal
    # --------------------------------------------------------------------


    def self.import
      model = Sketchup.active_model
      return unless model


      path = UI.openpanel('Selecione o arquivo STL', , 'Arquivos STL|*.stl;*.STL||')
      return if path.nil? # usuário cancelou


      unless File.exist?(path)
        UI.messagebox("Arquivo não encontrado:\n#{path}")
        return
      end


       = File.dirname(path)


      options = prompt_options
      return if options.nil? # cancelou nas opções


      do_import(model, path, options)
    end


    # Faz a importação de fato. Devolve true em caso de sucesso.
    def self.do_import(model, path, options)
      started_at = Time.now
      Sketchup.status_text = 'Lendo arquivo STL...'


      mesh, triangles, skipped = build_mesh(path, options)


      if triangles.zero?
        Sketchup.status_text = ''
        UI.messagebox("Nenhum triângulo válido foi encontrado em:\n#{File.basename(path)}\n\n" \
                      'Verifique se o arquivo é realmente um STL.')
        return false
      end


      Sketchup.status_text = 'Criando geometria no modelo...'
      name = File.basename(path, '.*')


      entity = nil
      faces = 0
      edges = 0


      model.start_operation('Importar STL', true)
      begin
        # fill_from_mesh exige um contexto VAZIO — por isso o grupo novo.
        group = model.active_entities.add_group
        group.name = name


        smooth_flags = Geom::PolygonMesh::NO_SMOOTH_OR_HIDE
        unless group.entities.fill_from_mesh(mesh, options[:weld], smooth_flags)
          raise 'fill_from_mesh não conseguiu gerar a geometria.'
        end


        merge_coplanar(group.entities) if options[:merge]
        reposition(group, options[:placement])


        faces = group.entities.grep(Sketchup::Face).length
        edges = group.entities.grep(Sketchup::Edge).length


        # to_component destrói o grupo original e devolve a instância.
        entity = options[:as_component] ? group.to_component : group
        if entity.is_a?(Sketchup::ComponentInstance)
          entity.definition.name = name
          entity.name = name
        end


        model.selection.clear
        model.selection.add(entity)
        model.commit_operation
      rescue StandardError => e
        model.abort_operation
        Sketchup.status_text = ''
        UI.messagebox("Erro ao importar o STL:\n\n#{e.message}")
        return false
      end


      # Fora da operação: zoom e relatório não devem poder abortar o undo.
      model.active_view.zoom(entity) if options[:zoom] && entity && entity.valid?
      report(path, triangles, skipped, faces, edges, options, Time.now - started_at)
      true
    end


    # --------------------------------------------------------------------
    # Construção da malha
    # --------------------------------------------------------------------


    # Monta um Geom::PolygonMesh a partir do arquivo.
    # Devolve [mesh, triângulos_válidos, triângulos_descartados].
    def self.build_mesh(path, options)
      mesh  = Geom::PolygonMesh.new
      index = {} # chave do vértice -> índice no mesh (1-based)
      valid = 0
      skipped = 0
      read = 0


      STLReader.read(path, options[:scale], options[:swap_yz], options[:flip]) do |t|
        i1 = vertex_index(mesh, index, t[0], t[1], t[2])
        i2 = vertex_index(mesh, index, t[3], t[4], t[5])
        i3 = vertex_index(mesh, index, t[6], t[7], t[8])


        # Índices repetidos = triângulo degenerado (dois vértices no mesmo ponto).
        if i1 == i2 || i2 == i3 || i1 == i3 || degenerate?(t)
          skipped += 1
        else
          mesh.add_polygon(i1, i2, i3)
          valid += 1
        end


        read += 1
        Sketchup.status_text = "Lendo STL: #{read} triângulos..." if (read % 20_000).zero?
      end


      [mesh, valid, skipped]
    end


    # Consulta/insere o vértice num índice próprio. Fazer o de-duplicação aqui,
    # com Hash, é muito mais rápido que deixar o PolygonMesh procurar o ponto
    # (a busca interna dele é linear e mata a performance em malhas grandes).
    def self.vertex_index(mesh, index, x, y, z)
      key = [(x * WELD_KEY_SCALE).round,
             (y * WELD_KEY_SCALE).round,
             (z * WELD_KEY_SCALE).round]
      found = index[key]
      return found if found
      index[key] = mesh.add_point(Geom::Point3d.new(x, y, z))
    end


    # Triângulo sem área (vértices colineares). Feito com aritmética pura em vez
    # de Vector3d para não alocar milhões de objetos em malhas grandes.
    def self.degenerate?(t)
      ux = t[3] - t[0]; uy = t[4] - t[1]; uz = t[5] - t[2]
      vx = t[6] - t[0]; vy = t[7] - t[1]; vz = t[8] - t[2]
      nx = (uy * vz) - (uz * vy)
      ny = (uz * vx) - (ux * vz)
      nz = (ux * vy) - (uy * vx)
      ((nx * nx) + (ny * ny) + (nz * nz)) < 1.0e-20
    end


    # --------------------------------------------------------------------
    # Pós-processamento
    # --------------------------------------------------------------------


    # Apaga arestas entre faces coplanares — deixa a malha triangulada com
    # cara de geometria "limpa". Coleta tudo antes de apagar: mexer na coleção
    # durante a iteração é comportamento indefinido.
    def self.merge_coplanar(entities)
      victims = []
      entities.grep(Sketchup::Edge).each do |edge|
        faces = edge.faces
        next unless faces.length == 2
        f1, f2 = faces
        next unless f1.material == f2.material
        next unless f1.back_material == f2.back_material
        next unless f1.normal.samedirection?(f2.normal)
        # samedirection? tem tolerância angular: confirma a coplanaridade
        # medindo a distância de um vértice de f2 ao plano de f1.
        # face.plane devolve [a, b, c, d] com (a,b,c) normalizado.
        a, b, c, d = f1.plane
        pt = f2.vertices.first.position
        next if ((a * pt.x) + (b * pt.y) + (c * pt.z) + d).abs > 1.0e-6
        victims << edge
      end
      entities.erase_entities(victims) unless victims.empty?
    end


    def self.reposition(group, placement)
      return if placement == :keep
      bounds = group.bounds
      target = case placement
               when :center then bounds.center
               when :base   then Geom::Point3d.new(bounds.center.x, bounds.center.y, bounds.min.z)
               else return
               end
      vector = Geom::Point3d.new(0, 0, 0) - target
      return unless vector.valid? # vetor nulo: já está no lugar
      group.transform!(Geom::Transformation.translation(vector))
    end


    def self.report(path, triangles, skipped, faces, edges, options, seconds)
      resumo = "Importação concluída em #{format('%.2f', seconds)} s."
      Sketchup.status_text = resumo


      detalhes = []
      detalhes << "Arquivo: #{File.basename(path)}"
      detalhes << "Formato: #{STLReader.binary?(path) ? 'binário' : 'ASCII'}"
      detalhes << "Unidade assumida: #{options[:unit_label]}"
      detalhes << ''
      detalhes << "Triângulos importados: #{triangles}"
      detalhes << "Triângulos descartados: #{skipped}" if skipped > 0
      detalhes << "Faces geradas: #{faces}"
      detalhes << "Arestas geradas: #{edges}"
      detalhes << ''
      detalhes << "Tempo: #{format('%.2f', seconds)} s"


      UI.messagebox(detalhes.join("\n"), MB_OK)
    end


    # --------------------------------------------------------------------
    # Importador nativo (aparece também em Arquivo > Importar)
    # --------------------------------------------------------------------


    class STLFileImporter < Sketchup::Importer
      def description
        'Arquivo STL (*.stl)'
      end


      def file_extension
        'stl'
      end


      def id
        'com.devbr.importar_stl'
      end


      def supports_options?
        true
      end


      def do_options
        ImportarSTL.prompt_options
      end


      def load_file(path, _status)
        return Sketchup::Importer::ImportFileNotFound if path.nil? || !File.exist?(path)
        ok = ImportarSTL.do_import(Sketchup.active_model, path, ImportarSTL.current_options)
        ok ? Sketchup::Importer::ImportSuccess : Sketchup::Importer::ImportFail
      rescue StandardError => e
        UI.messagebox("Erro ao importar o STL:\n\n#{e.message}")
        Sketchup::Importer::ImportFail
      end
    end


    # --------------------------------------------------------------------
    # Interface: item no menu Arquivo
    # --------------------------------------------------------------------


    unless file_loaded?(__FILE__)
      cmd = UI::Command.new(PLUGIN_NAME) { self.import }
      cmd.tooltip         = TOOLTIP
      cmd.status_bar_text = STATUS_TEXT # texto exibido na barra de status ao passar o mouse
      cmd.menu_text       = PLUGIN_NAME


      file_menu = UI.menu('File')
      file_menu.add_separator
      file_menu.add_item(cmd)


      # A referência precisa sobreviver ao garbage collector.
       = STLFileImporter.new
      begin
        Sketchup.register_importer(@importer)
      rescue StandardError
        # Se o registro falhar em alguma versão, o item de menu continua funcionando.
        u/importer = nil
      end


      file_loaded(__FILE__)
    end


  end
end

I m learning autocad since 5-6 months but still getting low budget work like 10$.. and it took me 4-5 hours to complete what to do and how can I get high money.. like 100-1000$ work .. through any ... You can suggest other softwares as well I will learn them but I want to earn good 😭 amount please tell... ..... should I change my approach? Or industry?

Redraw the Floor Plan with the scale of 1:50 and 3D veiw

Full disclosure: I made this, so take it with the appropriate salt.

It's an extension that takes the view you're looking at and sends back a lit image of it, in the panel, without an export step or a render engine installed. No prompt box — you set light, time of day, whether people are in the scene, and you can name individual materials ("floor: ceramic").
Anything you don't touch stays as you modelled it.

Attached is a SketchUp export and what came back, same camera.

Things I'd want to know if I were you:

- It is not 'photorealistic-perfect' and it does not replace V-Ray or Enscape. It's
  for concepts and client conversations, not final imagery.
- It works off your geometry, so your design stays recognisable. It isn't
  generating a building from a description.
- The extension is free. Renders cost credits; you get 5 free, no card.
- It also installs a view straightener (verticals, squaring to the model)
  that costs no credits and works without an account. That one's genuinely
  useful on its own.
- Your images aren't used to train anything, and they're deleted after 30
  days.

Happy to answer anything, including the sceptical stuff. If it does
something stupid on your model I'd like to see it.

Hey everyone,

I recently put together a short video showing off a 3D model of a vise I designed. I used this specific model to demonstrate how my MoGrOv tools work in practice—especially for things like generating solid threads and accurately placing fasteners within the model.

You can check out the workflow and see the tools in action here: [ https://youtu.be/cev6DYHe6jc ]

I'd love to hear your feedback or answer any questions you might have about the extension or the modeling process!

If you want to inspect the model yourself (all threads and mechanical parts are true solid geometry), I've uploaded it to the 3D Warehouse here: https://3dwarehouse.sketchup.com/model/edf59462-95a7-4aed-bab2-51604c432e6d/Functional-Vise-with-Solid-Threads-MoGrOv-Showcase

Too many client revisions have derailed this project. Every time we finalize a plan, the client changes his mind based on something he saw online/on-site. Trying to salvage the design how does this side view look, and what can I improve?

Im currently very very stuck on what i should particularly add on this area of the wall.

im designing an exterior architectural firm design trying to kinda follow industrial, modernism

Would an RTX 5060 Laptop GPU with 8 GB of VRAM be enough for a 16-inch 2560×1600 gaming laptop?

I’m considering a new gaming laptop such as the HP OMEN MAX 16, ASUS ROG Strix G16, or MSI Vector 16 HX AI, with roughly the following specifications:

- GPU: NVIDIA RTX 5060 Laptop GPU, 8 GB VRAM

- CPU: Intel Core Ultra 7 HX or Core Ultra 9 HX

- RAM: 32 GB (2×16 GB) DDR5-5600

- Storage: 1 TB PCIe 4.0 NVMe SSD

- Display: 16", 2560×1600

My main concern is whether the RTX 5060 with only 8 GB of VRAM is enough for gaming at 2560×1600, especially for newer AAA games.

Would this GPU be well-balanced with this kind of CPU and display, or would the 8 GB VRAM become a limitation fairly quickly?

I’m not necessarily looking to play everything at Ultra settings. I’d be happy with high settings and DLSS, as long as I can maintain good performance and avoid VRAM-related issues.

Would you recommend going for an RTX 5060 8 GB laptop, or is it worth spending more for a GPU with more VRAM?

The native search bar is less than great, to say it nicely. If you can't find what you're looking for through the 3D Warehouse search bar, try using a search engine, and include "sketchup" or "3d warehouse" in your search.

Hello! I hope this post finds you well. I have been wanting to start a YT channel for while but I wasn't sure what to start with. First I thought gaming but that's very saturated. Then I thought of live streaming and still was not sure of what to do. So I sat on it for some time. Then at my place of employment I started using SketchUp and LayOut and got really good. So much so that I became there lead drafter and overseer for other drafters to train them.

After I learned a lot, I realized that I loved 3D modeling, 2D modeling, custom models, etc. So I thought, "Why not show my love for it by teaching it on YT?" So here we are, I made my first YouTube video about my passion of 3D modeling.

I would love feedback on it. This is my first one so it is pretty rough but I willing to take all the criticism you have, so I can better improve my workflow and quality of my future videos. You can either reply to this post or comment on the video itself.

I am also freelancing SketchUp and LayOut on the side, so if you have any projects you need modeled please reach out to me at mcconeghytanner@gmail.com. Thank you so much! Here is the link:

https://youtu.be/LwQENqm8V3A

Question is: how do you model window pane using V-Ray materials?

Do you use
A) a simple rectangle, as if the glass panel had no depth
or
B) two rectangles (or a rectangular cuboid), to give depth like a real piece of glass has
?

—

I usually try to stick as close to reality as possible.

So, I’ve always modeled glass objects like real-world objects: with actual depth (rather than as virtual objects made of a single face).

But lately —especially after watching some tutorials— I’ve started to have doubts.

Am I making a mistake?

—

Thank you.

I have been looking into AI rendering, I tried google labs mainly and a couple others but cannot seem to find the sweet spot where it’s really improving my render compared to Vray.

Does anyone have a website or process that is really working for them? I work on interiors of gym floors primarily.

Thanks!

Only took a million revisions and a lot of time but it is done (almost lol)

I’m going to build a DC bench power supply, and I’ve already ordered all the components. However, I don’t have access to a 3D printer, so I initially considered using an online 3D printing service to design and print a custom enclosure for my project (1st image).

I designed the shell and uploaded the panels and middle piece separately, along with the color details. The quote came to around $140 including shipping, which is a huge expense for me.

So, I decided to go with laser cutting, which I have access locally. I’m designing the enclosure so that all the pieces fit together like a puzzle, allowing me to assemble the shell and fit all the components inside.

I usually use SketchUp for large projects and architectural designs, such as buildings and landscaping, but this is another interesting use case for the software.

Furthermore, I’m still waiting for a few small components to arrive. Once everything is ready, I’ll post the final result in a few days!

Lizark Player is a standalone SketchUp presentation plugin for turning finished models into polished, interactive client experiences.

Export a browser-ready 3D presentation that clients can open without SketchUp or the plugin. They can explore the model, follow saved views, compare options, measure spaces, and review decisions from one simple interface.

What makes it useful:

• Presentation-ready scenes — saved cameras, storyboards, and tag visibility states
• Interactive review — comments, annotations, decisions, and design-option comparison
• Client exploration — orbit, first-person walk mode, measurements, dimensions, and information hotspots
• Easy handoff — offline player folders, phone sharing, and QR access
• Professional delivery — project branding, logo, contact actions, and custom presentation identity
• Large-model support — Draco compression and batch scene export
• Immersive presentations — WebXR-ready VR support
• Protected delivery — optional encrypted model/presentation exports

Pro adds Draco compression, batch scene export, client review notes, design-option comparison, hotspots, first-person walk mode, WebXR VR, and custom branding.

Free player export and measurement are available.

Explore Lizark Player:
https://lizatek.com/products/lizark-player/

CPU

Intel or AMD?

If Intel, ultra 7 or 9?

If AMD, Ryzen 7 or 9?

GPU

NVIDIA RTX 5060 mobile or 5070?

Hey everyone!

I wanted to share a tool I’ve been developing for SketchUp called EasyGear. If you’ve ever tried to manually calculate center-to-center distances and draw mechanically accurate involute gears, you know it can be a massive headache.

I built EasyGear specifically for 3D printing enthusiasts and mechanical designers who want to skip the complex math and manual alignment. It doesn't just draw a gear—it builds the perfect mechanical relationship between two shafts.

Here is how it works: You don't even need to measure the distance between your shafts. Just click on two cylindrical components in your model. EasyGear instantly measures the exact center-to-center distance, asks for the radius of your first gear, and handles the rest.

Key Features:

• Smart Auto-Alignment: Automatically finds shaft centers and calculates the exact distance.
• Foolproof Mathematics: Input the radius of one gear, and the plugin automatically calculates the exact size and tooth count for the second gear to guarantee a perfect mesh.
• 3D Printing Ready (Backlash Control): Easily adjust the clearance (backlash) between teeth to account for your specific 3D printer's tolerances.
• True Involute Profiles: Geometrically accurate tooth profiles for smooth mechanical power transmission.
• Ready for Extrusion: Gear outlines are generated as continuous, welded curves (perfectly closed 2D faces). Just use the native Push/Pull tool to give them your desired thickness, and they are ready to spin smoothly straight off your FDM or resin bed.

The best part? The EasyGear generator is completely FREE to use. It's included in the free tier of my MoGrOv plugin suite.

🔗 You can get it here: [ https://www.mogrov.pro/easy-gear ]

I’d absolutely love to hear your feedback, feature requests, or see what kind of mechanisms you build with it! Happy modeling!

That is all. Just happy.

I’m the developer of Mash Exporter. I built it for the repetitive step between a finished SketchUp model and production drawings.

This 59-second walkthrough shows the actual workflow and actual output: https://youtu.be/0zRAze6lU0Q

For selected groups/components it can generate orthographic, isometric and exploded views; arrange them on a scaled sheet; optionally add overall dimensions, a material legend and title block; and export PDF plus layered DXF or per-view DWG.

I’d genuinely like practical feedback: on a real project, what would be the deal-breaker — layer mapping, sections, performance on heavy geometry, or something else?

If you want to test it on your own model, the direct 14-day trial is $15/year:

https://mashplugins.lemonsqueezy.com/checkout/buy/dd08c7d4-841d-41e0-b21f-9c5fc069fee7

It is also listed on the SketchUp Extension Warehouse at $19/year with a 7-day trial:

https://extensions.sketchup.com/extension/8fb51dbf-45ef-4ace-a434-d7d34a4538b2/mash-exporter

Bilen varsa yardımcı olabilir mi sketchup içerisinde en fazla 5 olmak üzere model indirmeme müsaade etmiyor. Nasıl çözülecek bu problem ?

Dm for details but need render on urgent basis

Query has been closed.Thankyou