Textures for OpenSCAD Preview mode

CMakeLists.txt

@@ -376,6 +376,10 @@ message(STATUS "Flex: ${FLEX_VERSION}")
 find_package(BISON REQUIRED QUIET)
 message(STATUS "Bison: ${BISON_VERSION}")
 
+find_package(JPEG REQUIRED QUIET)
+target_include_directories(OpenSCAD SYSTEM PRIVATE ${JPEG_INCLUDE_DIRS})
+target_link_libraries(OpenSCAD PRIVATE ${JPEG_LIBRARIES})
+
 if(NOT MSVC)
   find_package(Lib3MF QUIET)
   if (LIB3MF_FOUND)
@@ -571,6 +575,7 @@ set(CORE_SOURCES
   src/core/CgalAdvNode.cc
   src/core/Children.cc
   src/core/ColorNode.cc
+  src/core/TextureNode.cc
   src/core/Context.cc
   src/core/ContextFrame.cc
   src/core/ContextMemoryManager.cc
@@ -889,6 +894,7 @@ if(APPLE AND NOT APPLE_UNIX)
   file(COPY ${CMAKE_SOURCE_DIR}/libraries DESTINATION ${BUNDLE_RESOURCES_DIR})
   file(COPY ${CMAKE_SOURCE_DIR}/locale DESTINATION ${BUNDLE_RESOURCES_DIR})
   file(COPY ${CMAKE_SOURCE_DIR}/shaders DESTINATION ${BUNDLE_RESOURCES_DIR})
+  file(COPY ${CMAKE_SOURCE_DIR}/textures DESTINATION ${BUNDLE_RESOURCES_DIR})
   file(COPY ${CMAKE_SOURCE_DIR}/templates DESTINATION ${BUNDLE_RESOURCES_DIR})
 elseif(MINGW)
   set_target_properties(OpenSCAD PROPERTIES
@@ -954,6 +960,7 @@ if(NOT APPLE OR APPLE_UNIX)
   install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/libraries DESTINATION "${OPENSCAD_INSTALL_RESOURCEDIR}" PATTERN ".git*" EXCLUDE)
   install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/locale DESTINATION "${OPENSCAD_INSTALL_RESOURCEDIR}" FILES_MATCHING PATTERN "*/LC_MESSAGES/openscad.mo")
   install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/shaders DESTINATION "${OPENSCAD_INSTALL_RESOURCEDIR}")
+  install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/textures DESTINATION "${OPENSCAD_INSTALL_RESOURCEDIR}")
   install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/templates DESTINATION "${OPENSCAD_INSTALL_RESOURCEDIR}" FILES_MATCHING PATTERN "*.json")
 endif()
 

cmake/Modules/FindJPEG.cmake

@@ -0,0 +1,141 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindJPEG
+--------
+
+Find the Joint Photographic Experts Group (JPEG) library (``libjpeg``)
+
+Imported targets
+^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.12
+
+This module defines the following :prop_tgt:`IMPORTED` targets:
+
+``JPEG::JPEG``
+  The JPEG library, if found.
+
+Result variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``JPEG_FOUND``
+  If false, do not try to use JPEG.
+``JPEG_INCLUDE_DIRS``
+  where to find jpeglib.h, etc.
+``JPEG_LIBRARIES``
+  the libraries needed to use JPEG.
+``JPEG_VERSION``
+  .. versionadded:: 3.12
+    the version of the JPEG library found
+
+Cache variables
+^^^^^^^^^^^^^^^
+
+The following cache variables may also be set:
+
+``JPEG_INCLUDE_DIRS``
+  where to find jpeglib.h, etc.
+``JPEG_LIBRARY_RELEASE``
+  where to find the JPEG library (optimized).
+``JPEG_LIBRARY_DEBUG``
+  where to find the JPEG library (debug).
+
+.. versionadded:: 3.12
+  Debug and Release variand are found separately.
+
+Obsolete variables
+^^^^^^^^^^^^^^^^^^
+
+``JPEG_INCLUDE_DIR``
+  where to find jpeglib.h, etc. (same as JPEG_INCLUDE_DIRS)
+``JPEG_LIBRARY``
+  where to find the JPEG library.
+#]=======================================================================]
+
+find_path(JPEG_INCLUDE_DIR jpeglib.h)
+
+set(jpeg_names ${JPEG_NAMES} jpeg jpeg-static libjpeg libjpeg-static)
+foreach(name ${jpeg_names})
+  list(APPEND jpeg_names_debug "${name}d")
+endforeach()
+
+if(NOT JPEG_LIBRARY)
+  find_library(JPEG_LIBRARY_RELEASE NAMES ${jpeg_names} NAMES_PER_DIR)
+  find_library(JPEG_LIBRARY_DEBUG NAMES ${jpeg_names_debug} NAMES_PER_DIR)
+  select_library_configurations(JPEG)
+  mark_as_advanced(JPEG_LIBRARY_RELEASE JPEG_LIBRARY_DEBUG)
+endif()
+unset(jpeg_names)
+unset(jpeg_names_debug)
+
+if(JPEG_INCLUDE_DIR)
+  file(GLOB _JPEG_CONFIG_HEADERS_FEDORA "${JPEG_INCLUDE_DIR}/jconfig*.h")
+  file(GLOB _JPEG_CONFIG_HEADERS_DEBIAN "${JPEG_INCLUDE_DIR}/*/jconfig.h")
+  set(_JPEG_CONFIG_HEADERS
+    "${JPEG_INCLUDE_DIR}/jpeglib.h"
+    ${_JPEG_CONFIG_HEADERS_FEDORA}
+    ${_JPEG_CONFIG_HEADERS_DEBIAN})
+  foreach (_JPEG_CONFIG_HEADER IN LISTS _JPEG_CONFIG_HEADERS)
+    if (NOT EXISTS "${_JPEG_CONFIG_HEADER}")
+      continue ()
+    endif ()
+    file(STRINGS "${_JPEG_CONFIG_HEADER}"
+      jpeg_lib_version REGEX "^#define[\t ]+JPEG_LIB_VERSION[\t ]+.*")
+
+    if (NOT jpeg_lib_version)
+      continue ()
+    endif ()
+
+    string(REGEX REPLACE "^#define[\t ]+JPEG_LIB_VERSION[\t ]+([0-9]+).*"
+      "\\1" JPEG_VERSION "${jpeg_lib_version}")
+    break ()
+  endforeach ()
+  unset(jpeg_lib_version)
+  unset(_JPEG_CONFIG_HEADER)
+  unset(_JPEG_CONFIG_HEADERS)
+  unset(_JPEG_CONFIG_HEADERS_FEDORA)
+  unset(_JPEG_CONFIG_HEADERS_DEBIAN)
+endif()
+
+find_package_handle_standard_args(JPEG
+  REQUIRED_VARS JPEG_LIBRARY JPEG_INCLUDE_DIR
+  VERSION_VAR JPEG_VERSION)
+
+if(JPEG_FOUND)
+  set(JPEG_LIBRARIES ${JPEG_LIBRARY})
+  set(JPEG_INCLUDE_DIRS "${JPEG_INCLUDE_DIR}")
+
+  if(NOT TARGET JPEG::JPEG)
+    add_library(JPEG::JPEG UNKNOWN IMPORTED)
+    if(JPEG_INCLUDE_DIRS)
+      set_target_properties(JPEG::JPEG PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${JPEG_INCLUDE_DIRS}")
+    endif()
+    if(EXISTS "${JPEG_LIBRARY}")
+      set_target_properties(JPEG::JPEG PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION "${JPEG_LIBRARY}")
+    endif()
+    if(EXISTS "${JPEG_LIBRARY_RELEASE}")
+      set_property(TARGET JPEG::JPEG APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(JPEG::JPEG PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
+        IMPORTED_LOCATION_RELEASE "${JPEG_LIBRARY_RELEASE}")
+    endif()
+    if(EXISTS "${JPEG_LIBRARY_DEBUG}")
+      set_property(TARGET JPEG::JPEG APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(JPEG::JPEG PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
+        IMPORTED_LOCATION_DEBUG "${JPEG_LIBRARY_DEBUG}")
+    endif()
+  endif()
+endif()
+
+mark_as_advanced(JPEG_LIBRARY JPEG_INCLUDE_DIR)
+

shaders/Preview.frag

@@ -1,8 +1,11 @@
 #version 110
 
 uniform vec4 color1, color2;
+uniform int drawEdges;
 varying vec3 vBC;
+uniform sampler2D tex1;
 varying float shading;
+varying float textureEnableTrans;
 
 vec3 smoothstep3f(vec3 edge0, vec3 edge1, vec3 x) {
   vec3 t;
@@ -11,6 +14,9 @@ vec3 smoothstep3f(vec3 edge0, vec3 edge1, vec3 x) {
 }
 
 float edgeFactor() {
+  if(drawEdges != 1) {
+    return 1.0; // only mix in the edge color when edges are shown
+  }
   const float th = 1.414; // total thickness of half-edge (per triangle) including fade, (must be >= fade)
   const float fade = 1.414; // thickness of fade (antialiasing) in screen pixels
   vec3 d = fwidth(vBC);
@@ -19,5 +25,12 @@ float edgeFactor() {
 }
 
 void main(void) {
-  gl_FragColor = mix(color2, vec4(color1.rgb * shading, color1.a), edgeFactor());
+  vec4 facecolor = color1;
+
+  if(textureEnableTrans > 0.5 ) {
+    vec4 texel = texture2D(tex1,gl_TexCoord[0].st);
+    vec4 gray; gray.r=0.5; gray.g=0.5; gray.b=0.5;
+    facecolor.rgb = facecolor.rgb + texel.rgb - gray.rgb;
+  } 
+  gl_FragColor = mix(color2, vec4(facecolor.rgb * shading, facecolor.a), edgeFactor());
 }

shaders/Preview.vert

@@ -2,13 +2,17 @@
 
 uniform vec4 color1;        // face color
 uniform vec4 color2;        // edge color
+attribute float textureEnable;
 attribute vec3 barycentric; // barycentric form of vertex coord
                             // either [1,0,0], [0,1,0] or [0,0,1] under normal circumstances (no edges disabled)
 varying vec3 vBC;           // varying barycentric coords
 varying float shading;      // multiplied by color1. color2 is without lighting
+varying float textureEnableTrans;
 
 void main(void) {
   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+  textureEnableTrans=textureEnable;
+  gl_TexCoord[0] = gl_MultiTexCoord0;
   vBC = barycentric;
   vec3 normal, lightDir;
   normal = normalize(gl_NormalMatrix * gl_Normal);

src/core/Builtins.cc

@@ -46,6 +46,7 @@ extern void register_builtin_group();
 extern void register_builtin_csgops();
 extern void register_builtin_transform();
 extern void register_builtin_color();
+extern void register_builtin_texture();
 extern void register_builtin_primitives();
 extern void register_builtin_surface();
 extern void register_builtin_control();
@@ -75,6 +76,7 @@ void Builtins::initialize()
   register_builtin_csgops();
   register_builtin_transform();
   register_builtin_color();
+  register_builtin_texture();
   register_builtin_primitives();
   register_builtin_surface();
   register_builtin_control();

src/core/CSGNode.cc

@@ -65,7 +65,7 @@
  */
 
 shared_ptr<CSGNode> CSGNode::createEmptySet() {
-  return shared_ptr<CSGNode>(new CSGLeaf(nullptr, Transform3d(), Color4f(), "empty()", 0));
+  return shared_ptr<CSGNode>(new CSGLeaf(nullptr, Transform3d(), Color4f(), 0, "empty()", 0));
 }
 
 shared_ptr<CSGNode> CSGOperation::createCSGNode(OpenSCADOperator type, shared_ptr<CSGNode> left, shared_ptr<CSGNode> right)
@@ -114,8 +114,8 @@ shared_ptr<CSGNode> CSGOperation::createCSGNode(OpenSCADOperator type, shared_pt
   return {new CSGOperation(type, left, right), CSGOperationDeleter()};
 }
 
-CSGLeaf::CSGLeaf(const shared_ptr<const Geometry>& geom, Transform3d matrix, Color4f color, std::string label, const int index)
-  : label(std::move(label)), matrix(std::move(matrix)), color(std::move(color)), index(index)
+CSGLeaf::CSGLeaf(const shared_ptr<const Geometry>& geom, Transform3d matrix, Color4f color,int textureind, std::string label, const int index)
+  : label(std::move(label)), matrix(std::move(matrix)), color(std::move(color)),textureind(textureind), index(index)
 {
   if (geom && !geom->isEmpty()) this->geom = geom;
   CSGLeaf::initBoundingBox();

src/core/CSGNode.h

@@ -86,14 +86,15 @@ class CSGLeaf : public CSGNode
 {
 public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-  CSGLeaf(const shared_ptr<const Geometry>& geom, Transform3d matrix, Color4f color, std::string label, const int index);
+  CSGLeaf(const shared_ptr<const Geometry>& geom, Transform3d matrix, Color4f color,int textureind, std::string label, const int index);
   void initBoundingBox() override;
   [[nodiscard]] bool isEmptySet() const override;
   [[nodiscard]] std::string dump() const override;
   std::string label;
   shared_ptr<const Geometry> geom;
   Transform3d matrix;
   Color4f color;
+  int textureind;
 
   const int index;
 

src/core/CSGTreeEvaluator.cc

@@ -182,7 +182,7 @@ shared_ptr<CSGNode> CSGTreeEvaluator::evaluateCSGNodeFromGeometry(
     // 3D PolySets are tessellated before inserting into Geometry cache, inside GeometryEvaluator::evaluateGeometry
   }
 
-  shared_ptr<CSGNode> t(new CSGLeaf(g, state.matrix(), state.color(), STR(node.name(), node.index()), node.index()));
+  shared_ptr<CSGNode> t(new CSGLeaf(g, state.matrix(), state.color(),state.textureind(), STR(node.name(), node.index()), node.index()));
   if (modinst->isHighlight() || state.isHighlight()) t->setHighlight(true);
   if (modinst->isBackground() || state.isBackground()) t->setBackground(true);
   return t;
@@ -235,7 +235,7 @@ Response CSGTreeEvaluator::visit(State& state, const TransformNode& node)
 Response CSGTreeEvaluator::visit(State& state, const ColorNode& node)
 {
   if (state.isPrefix()) {
-    if (!state.color().isValid()) state.setColor(node.color);
+    if (!state.color().isValid()) state.setColor(node.color,node.textureind);
   }
   if (state.isPostfix()) {
     applyToChildren(state, node, OpenSCADOperator::UNION);

src/core/ColorNode.cc

@@ -239,7 +239,7 @@ static std::shared_ptr<AbstractNode> builtin_color(const ModuleInstantiation *in
 {
   auto node = std::make_shared<ColorNode>(inst);
 
-  Parameters parameters = Parameters::parse(std::move(arguments), inst->location(), {"c", "alpha"});
+  Parameters parameters = Parameters::parse(std::move(arguments), inst->location(), {"c", "alpha", "texture"});
   if (parameters["c"].type() == Value::Type::VECTOR) {
     const auto& vec = parameters["c"].toVector();
     for (size_t i = 0; i < 4; ++i) {
@@ -267,13 +267,17 @@ static std::shared_ptr<AbstractNode> builtin_color(const ModuleInstantiation *in
   if (parameters["alpha"].type() == Value::Type::NUMBER) {
     node->color[3] = parameters["alpha"].toDouble();
   }
+  node->textureind=0; 
+  if (parameters["texture"].type() == Value::Type::NUMBER) {
+    node->textureind = (int) parameters["texture"].toDouble();
+  }
 
   return children.instantiate(node);
 }
 
 std::string ColorNode::toString() const
 {
-  return STR("color([", this->color[0], ", ", this->color[1], ", ", this->color[2], ", ", this->color[3], "])");
+  return STR("color([", this->color[0], ", ", this->color[1], ", ", this->color[2], ", ", this->color[3], ", ",this->textureind, "])");
 }
 
 std::string ColorNode::name() const

src/core/ColorNode.h

@@ -7,9 +7,10 @@ class ColorNode : public AbstractNode
 {
 public:
   VISITABLE();
-  ColorNode(const ModuleInstantiation *mi) : AbstractNode(mi), color(-1.0f, -1.0f, -1.0f, 1.0f) { }
+  ColorNode(const ModuleInstantiation *mi) : AbstractNode(mi), color(-1.0f, -1.0f, -1.0f, 1.0f), textureind(0) { }
   std::string toString() const override;
   std::string name() const override;
 
   Color4f color;
+  int textureind;
 };

src/core/Expression.cc

@@ -607,6 +607,8 @@ Expression *FunctionCall::create(const std::string& funcname, const AssignmentLi
     return new Assert(arglist, expr, loc);
   } else if (funcname == "echo") {
     return new Echo(arglist, expr, loc);
+  } else if (funcname == "texture") {
+    return new Texture(arglist, expr, loc);
   } else if (funcname == "let") {
     return new Let(arglist, expr, loc);
   }
@@ -683,6 +685,32 @@ void Echo::print(std::ostream& stream, const std::string&) const
   if (this->expr) stream << " " << *this->expr;
 }
 
+
+const Expression *Texture::evaluateStep(const std::shared_ptr<const Context>& context) const
+{
+  Arguments arguments{this->arguments, context};
+//  LOG(message_group::Echo, Location::NONE, "", "%1$s", STR(arguments));
+  return expr.get();
+}
+
+
+Texture::Texture(AssignmentList args, Expression *expr, const Location& loc)
+  : Expression(loc), arguments(std::move(args)), expr(expr)
+{
+
+}
+Value Texture::evaluate(const std::shared_ptr<const Context>& context) const
+{
+  const Expression *nextexpr = evaluateStep(context);
+  return nextexpr ? nextexpr->evaluate(context) : Value::undefined.clone();
+}
+
+void Texture::print(std::ostream& stream, const std::string&) const
+{
+  stream << "tex2(" << this->arguments << ")";
+  if (this->expr) stream << " " << *this->expr;
+}
+
 Let::Let(AssignmentList args, Expression *expr, const Location& loc)
   : Expression(loc), arguments(std::move(args)), expr(expr)
 {