Merge pull request #6447 from huffman/polyline-texture

Add texture property to polyline entity type

examples/libraries/line.js

@@ -19,10 +19,11 @@ var MAX_LINE_LENGTH = 40; // This must be 2 or greater;
 var DEFAULT_STROKE_WIDTH = 0.1;
 var DEFAULT_LIFETIME = 20;
 var DEFAULT_COLOR = { red: 255, green: 255, blue: 255 };
-var PolyLine = function(position, color, lifetime) {
+var PolyLine = function(position, color, lifetime, texture) {
     this.position = position;
     this.color = color;
     this.lifetime = lifetime === undefined ? DEFAULT_LIFETIME : lifetime;
+    this.texture = texture ? texture : "";
     this.points = [
     ];
     this.strokeWidths = [
@@ -37,7 +38,8 @@ var PolyLine = function(position, color, lifetime) {
         strokeWidths: this.strokeWidths,
         dimensions: LINE_DIMENSIONS,
         color: color,
-        lifetime: lifetime
+        lifetime: lifetime,
+        textures: this.texture
     });
 };
 
@@ -98,26 +100,29 @@ PolyLine.prototype.destroy = function() {
 
 
 // InfiniteLine
-InfiniteLine = function(position, color, lifetime) {
+InfiniteLine = function(position, color, lifetime, textureBegin, textureMiddle) {
     this.position = position;
     this.color = color;
     this.lifetime = lifetime === undefined ? DEFAULT_LIFETIME : lifetime;
     this.lines = [];
     this.size = 0;
+
+    this.textureBegin = textureBegin ? textureBegin : "";
+    this.textureMiddle = textureMiddle ? textureMiddle : "";
 };
 
 InfiniteLine.prototype.enqueuePoint = function(position, strokeWidth) {
     var currentLine;
 
     if (this.lines.length == 0) {
-        currentLine = new PolyLine(position, this.color, this.lifetime);
+        currentLine = new PolyLine(position, this.color, this.lifetime, this.textureBegin);
         this.lines.push(currentLine);
     } else {
         currentLine = this.lines[this.lines.length - 1];
     }
 
     if (currentLine.isFull()) {
-        var newLine = new PolyLine(currentLine.getLastPoint(), this.color, this.lifetime);
+        var newLine = new PolyLine(currentLine.getLastPoint(), this.color, this.lifetime, this.textureMiddle);
         newLine.enqueuePoint(currentLine.getLastPoint(), strokeWidth);
         this.lines.push(newLine);
         currentLine = newLine;

libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp

@@ -36,7 +36,6 @@ PolyLineEntityItem(entityItemID, properties) {
 
 gpu::PipelinePointer RenderablePolyLineEntityItem::_pipeline;
 gpu::Stream::FormatPointer RenderablePolyLineEntityItem::_format;
-gpu::TexturePointer RenderablePolyLineEntityItem::_texture;
 int32_t RenderablePolyLineEntityItem::PAINTSTROKE_GPU_SLOT;
 
 void RenderablePolyLineEntityItem::createPipeline() {
@@ -44,9 +43,6 @@ void RenderablePolyLineEntityItem::createPipeline() {
     static const int COLOR_OFFSET = 24;
     static const int TEXTURE_OFFSET = 28;
 
-    auto textureCache = DependencyManager::get<TextureCache>();
-    QString path = PathUtils::resourcesPath() + "images/paintStroke.png";
-    _texture = textureCache->getImageTexture(path);
     _format.reset(new gpu::Stream::Format());
     _format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
     _format->setAttribute(gpu::Stream::NORMAL, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), NORMAL_OFFSET);
@@ -132,6 +128,13 @@ void RenderablePolyLineEntityItem::render(RenderArgs* args) {
         createPipeline();
     }
 
+    if (!_texture || _texturesChangedFlag) {
+        auto textureCache = DependencyManager::get<TextureCache>();
+        QString path = _textures.isEmpty() ? PathUtils::resourcesPath() + "images/paintStroke.png" : _textures;
+        _texture = textureCache->getTexture(QUrl(path));
+        _texturesChangedFlag = false;
+    }
+
     PerformanceTimer perfTimer("RenderablePolyLineEntityItem::render");
     Q_ASSERT(getType() == EntityTypes::PolyLine);
 
@@ -147,7 +150,11 @@ void RenderablePolyLineEntityItem::render(RenderArgs* args) {
     batch.setModelTransform(transform);
 
     batch.setPipeline(_pipeline);
-    batch.setResourceTexture(PAINTSTROKE_GPU_SLOT, _texture);
+    if (_texture->isLoaded()) {
+        batch.setResourceTexture(PAINTSTROKE_GPU_SLOT, _texture->getGPUTexture());
+    } else {
+        batch.setResourceTexture(PAINTSTROKE_GPU_SLOT, args->_whiteTexture);
+    }
 
     batch.setInputFormat(_format);
     batch.setInputBuffer(0, _verticesBuffer, 0, _format->getChannels().at(0)._stride);

libraries/entities-renderer/src/RenderablePolyLineEntityItem.h

@@ -12,10 +12,13 @@
 #ifndef hifi_RenderablePolyLineEntityItem_h
 #define hifi_RenderablePolyLineEntityItem_h
 
+
 #include <gpu/Batch.h>
+#include <GeometryCache.h>
 #include <PolyLineEntityItem.h>
 #include "RenderableEntityItem.h"
-#include <GeometryCache.h>
+#include <TextureCache.h>
+
 #include <QReadWriteLock>
 
 
@@ -29,9 +32,10 @@ public:
     
     SIMPLE_RENDERABLE();
     
+    NetworkTexturePointer _texture;
+
     static gpu::PipelinePointer _pipeline;
     static gpu::Stream::FormatPointer _format;
-    static gpu::TexturePointer _texture;
     static int32_t PAINTSTROKE_GPU_SLOT;
     
 protected:

libraries/entities/src/EntityItemProperties.cpp

@@ -432,6 +432,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_LINE_POINTS, linePoints);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_NORMALS, normals);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_STROKE_WIDTHS, strokeWidths);
+        COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_TEXTURES, textures);
     }
 
     // Sitting properties support
@@ -1011,6 +1012,7 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem
                 APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, properties.getLinePoints());
                 APPEND_ENTITY_PROPERTY(PROP_NORMALS, properties.getNormals());
                 APPEND_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, properties.getStrokeWidths());
+                APPEND_ENTITY_PROPERTY(PROP_TEXTURES, properties.getTextures());
             }
             
             APPEND_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, properties.getMarketplaceID());
@@ -1287,6 +1289,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NORMALS, QVector<glm::vec3>, setNormals);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXTURES, QString, setTextures);
     }
 
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MARKETPLACE_ID, QString, setMarketplaceID);

libraries/entities/src/PolyLineEntityItem.cpp

@@ -37,7 +37,8 @@ _pointsChanged(true),
 _points(QVector<glm::vec3>(0.0f)),
 _vertices(QVector<glm::vec3>(0.0f)),
 _normals(QVector<glm::vec3>(0.0f)),
-_strokeWidths(QVector<float>(0.0f))
+_strokeWidths(QVector<float>(0.0f)),
+_textures("")
 {
     _type = EntityTypes::PolyLine;
     _created = properties.getCreated();
@@ -56,6 +57,7 @@ EntityItemProperties PolyLineEntityItem::getProperties(EntityPropertyFlags desir
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(linePoints, getLinePoints);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(normals, getNormals);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(strokeWidths, getStrokeWidths);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(textures, getTextures);
 
     properties._glowLevel = getGlowLevel();
     properties._glowLevelChanged = false;
@@ -72,6 +74,7 @@ bool PolyLineEntityItem::setProperties(const EntityItemProperties& properties) {
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(linePoints, setLinePoints);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(normals, setNormals);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(strokeWidths, setStrokeWidths);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(textures, setTextures);
 
     if (somethingChanged) {
         bool wantDebug = false;
@@ -196,6 +199,7 @@ int PolyLineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
     READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
     READ_ENTITY_PROPERTY(PROP_NORMALS, QVector<glm::vec3>, setNormals);
     READ_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
+    READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
 
     return bytesRead;
 }
@@ -209,6 +213,7 @@ EntityPropertyFlags PolyLineEntityItem::getEntityProperties(EncodeBitstreamParam
     requestedProperties += PROP_LINE_POINTS;
     requestedProperties += PROP_NORMALS;
     requestedProperties += PROP_STROKE_WIDTHS;
+    requestedProperties += PROP_TEXTURES;
     return requestedProperties;
 }
 
@@ -228,6 +233,7 @@ void PolyLineEntityItem::appendSubclassData(OctreePacketData* packetData, Encode
     APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, getLinePoints());
     APPEND_ENTITY_PROPERTY(PROP_NORMALS, getNormals());
     APPEND_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, getStrokeWidths());
+    APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
 }
 
 void PolyLineEntityItem::debugDump() const {

libraries/entities/src/PolyLineEntityItem.h

@@ -67,7 +67,14 @@ class PolyLineEntityItem : public EntityItem {
     
     bool setStrokeWidths(const QVector<float>& strokeWidths);
     const QVector<float>& getStrokeWidths() const{ return _strokeWidths; }
-    
+
+    const QString& getTextures() const { return _textures; }
+    void setTextures(const QString& textures) {
+        if (_textures != textures) {
+            _textures = textures;
+            _texturesChangedFlag = true;
+        }
+    }
     
     virtual ShapeType getShapeType() const { return SHAPE_TYPE_LINE; }
 
@@ -90,6 +97,8 @@ class PolyLineEntityItem : public EntityItem {
     QVector<glm::vec3> _vertices;
     QVector<glm::vec3> _normals;
     QVector<float> _strokeWidths;
+    QString _textures;
+    bool _texturesChangedFlag { false };
     mutable QReadWriteLock _quadReadWriteLock;
 };
 

libraries/networking/src/udt/PacketHeaders.cpp

@@ -41,7 +41,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::EntityAdd:
         case PacketType::EntityEdit:
         case PacketType::EntityData:
-            return VERSION_ENTITIES_PARTICLES_ADDITIVE_BLENDING;
+            return VERSION_ENTITIES_POLYLINE_TEXTURE;
         case PacketType::AvatarData:
         case PacketType::BulkAvatarData:
         default:

libraries/networking/src/udt/PacketHeaders.h

@@ -159,5 +159,6 @@ const PacketVersion VERSION_ENTITIES_ANIMATION_PROPERTIES_GROUP = 46;
 const PacketVersion VERSION_ENTITIES_KEYLIGHT_PROPERTIES_GROUP = 47;
 const PacketVersion VERSION_ENTITIES_KEYLIGHT_PROPERTIES_GROUP_BIS = 48;
 const PacketVersion VERSION_ENTITIES_PARTICLES_ADDITIVE_BLENDING = 49;
+const PacketVersion VERSION_ENTITIES_POLYLINE_TEXTURE = 50;
 
 #endif // hifi_PacketHeaders_h