created a custom pipeline that is a static class variable for renderable quad entity item

interface/src/Application.cpp

@@ -797,7 +797,7 @@ void Application::initializeGL() {
     init();
     qCDebug(interfaceapp, "init() complete.");
 
-    // create thread for parsing of octee data independent of the main network and rendering threads
+    // create thread for parsing of octree data independent of the main network and rendering threads
     _octreeProcessor.initialize(_enableProcessOctreeThread);
     connect(&_octreeProcessor, &OctreePacketProcessor::packetVersionMismatch, this, &Application::notifyPacketVersionMismatch);
     _entityEditSender.initialize(_enableProcessOctreeThread);

libraries/entities-renderer/src/RenderableQuadEntityItem.cpp

@@ -20,6 +20,9 @@
 #include "RenderableQuadEntityItem.h"
 
 
+
+
+
 EntityItemPointer RenderableQuadEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     return EntityItemPointer(new RenderableQuadEntityItem(entityID, properties));
 }
@@ -29,6 +32,27 @@ QuadEntityItem(entityItemID, properties) {
     _format.reset(new gpu::Stream::Format());
     _format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
     _numVertices = 0;
+    
+
+}
+
+gpu::PipelinePointer RenderableQuadEntityItem::_pipeline;
+
+void RenderableQuadEntityItem::createPipeline() {
+    auto VS = DependencyManager::get<DeferredLightingEffect>()->getSimpleVertexShader();
+    auto PS = DependencyManager::get<DeferredLightingEffect>()->getSimplePixelShader();
+    gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PS));
+    
+    gpu::Shader::BindingSet slotBindings;
+    gpu::Shader::makeProgram(*program, slotBindings);
+    
+    gpu::StatePointer state = gpu::StatePointer(new gpu::State());
+    //state->setCullMode(gpu::State::CULL_BACK);
+    state->setDepthTest(true, true, gpu::LESS_EQUAL);
+    state->setBlendFunction(false,
+                            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+                            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+   _pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
 }
 
 
@@ -66,6 +90,11 @@ void RenderableQuadEntityItem::render(RenderArgs* args) {
     if (_quadVertices.size() < 4 ) {
         return;
     }
+    if (!_pipeline) {
+        createPipeline();
+    }
+    
+ 
     PerformanceTimer perfTimer("RenderableQuadEntityItem::render");
     Q_ASSERT(getType() == EntityTypes::Quad);
     
@@ -76,14 +105,13 @@ void RenderableQuadEntityItem::render(RenderArgs* args) {
     Transform transform = Transform();
     transform.setTranslation(getPosition());
     batch.setModelTransform(transform);
-    
 
-    DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch);
+    batch.setPipeline(_pipeline);
+    
     batch.setInputFormat(_format);
     batch.setInputBuffer(0, _verticesBuffer, 0, _format->getChannels().at(0)._stride);
-    batch.draw(gpu::TRIANGLE_STRIP, _numVertices, 0);
     
-
+    batch.draw(gpu::TRIANGLE_STRIP, _numVertices, 0);
     
     RenderableDebugableEntityItem::render(this, args);
 };

libraries/entities-renderer/src/RenderableQuadEntityItem.h

@@ -21,13 +21,15 @@
 class RenderableQuadEntityItem : public QuadEntityItem {
 public:
     static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
-    
+    static void createPipeline();
     RenderableQuadEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
     
     virtual void render(RenderArgs* args);
     
     SIMPLE_RENDERABLE();
     
+    static gpu::PipelinePointer _pipeline;
+    
 protected:
     void updateGeometry();
     gpu::Stream::FormatPointer _format;

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -116,6 +116,22 @@ void DeferredLightingEffect::bindSimpleProgram(gpu::Batch& batch, bool textured)
     }
 }
 
+gpu::ShaderPointer DeferredLightingEffect::getSimpleVertexShader() const {
+    if (_simpleProgram) {
+        return _simpleProgram->getProgram()->getShaders()[gpu::Shader::VERTEX];
+    } else {
+        return gpu::ShaderPointer();
+    }
+}
+
+gpu::ShaderPointer DeferredLightingEffect::getSimplePixelShader() const {
+    if (_simpleProgram) {
+        return _simpleProgram->getProgram()->getShaders()[gpu::Shader::PIXEL];
+    } else {
+        return gpu::ShaderPointer();
+    }
+}
+
 void DeferredLightingEffect::releaseSimpleProgram(gpu::Batch& batch) {
   //  DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(batch, true, false, false);
 }

libraries/render-utils/src/DeferredLightingEffect.h

@@ -78,6 +78,10 @@ public:
     void setGlobalAtmosphere(const model::AtmospherePointer& atmosphere) { _atmosphere = atmosphere; }
 
     void setGlobalSkybox(const model::SkyboxPointer& skybox);
+    
+    gpu::ShaderPointer getSimpleVertexShader() const;
+    gpu::ShaderPointer getSimplePixelShader() const;
+    
 private:
     DeferredLightingEffect() {}
     virtual ~DeferredLightingEffect() { }