mirror of
https://github.com/JulianGro/overte.git
synced 2025-05-07 10:40:10 +02:00
491 lines
24 KiB
C++
491 lines
24 KiB
C++
//
|
|
// GeometryCache.h
|
|
// interface/src/renderer
|
|
//
|
|
// Created by Andrzej Kapolka on 6/21/13.
|
|
// Copyright 2013 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#ifndef hifi_GeometryCache_h
|
|
#define hifi_GeometryCache_h
|
|
|
|
#include "model-networking/ModelCache.h"
|
|
|
|
#include <array>
|
|
|
|
#include <QMap>
|
|
#include <QRunnable>
|
|
|
|
#include <DependencyManager.h>
|
|
|
|
#include <shared/Shapes.h>
|
|
|
|
#include <gpu/Batch.h>
|
|
#include <gpu/Stream.h>
|
|
|
|
#include <render/ShapePipeline.h>
|
|
|
|
#include <graphics/Material.h>
|
|
#include <graphics/Asset.h>
|
|
|
|
class SimpleProgramKey;
|
|
|
|
typedef QPair<glm::vec2, float> Vec2FloatPair;
|
|
typedef QPair<Vec2FloatPair, Vec2FloatPair> Vec2FloatPairPair;
|
|
typedef QPair<glm::vec2, glm::vec2> Vec2Pair;
|
|
typedef QPair<Vec2Pair, Vec2Pair> Vec2PairPair;
|
|
typedef QPair<glm::vec3, glm::vec3> Vec3Pair;
|
|
typedef QPair<glm::vec4, glm::vec4> Vec4Pair;
|
|
typedef QPair<Vec3Pair, Vec2Pair> Vec3PairVec2Pair;
|
|
typedef QPair<Vec3Pair, glm::vec4> Vec3PairVec4;
|
|
typedef QPair<Vec3Pair, Vec4Pair> Vec3PairVec4Pair;
|
|
typedef QPair<Vec4Pair, glm::vec4> Vec4PairVec4;
|
|
typedef QPair<Vec4Pair, Vec4Pair> Vec4PairVec4Pair;
|
|
|
|
inline uint qHash(const Vec2FloatPairPair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.second +
|
|
5021 * v.second.first.x + 5023 * v.second.first.y + 5039 * v.second.second);
|
|
}
|
|
|
|
inline uint qHash(const Vec2Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.x + 5009 * v.first.y + 5011 * v.second.x + 5021 * v.second.y, seed);
|
|
}
|
|
|
|
inline uint qHash(const glm::vec4& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.x + 5009 * v.y + 5011 * v.z + 5021 * v.w, seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec2PairPair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y
|
|
+ 5011 * v.first.second.x + 5021 * v.first.second.y
|
|
+ 5023 * v.second.first.x + 5039 * v.second.first.y
|
|
+ 5051 * v.second.second.x + 5059 * v.second.second.y, seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec3Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.x + 5009 * v.first.y + 5011 * v.first.z
|
|
+ 5021 * v.second.x + 5023 * v.second.y + 5039 * v.second.z, seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec4Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.x + 5009 * v.first.y + 5011 * v.first.z + 5021 * v.first.w
|
|
+ 5023 * v.second.x + 5039 * v.second.y + 5051 * v.second.z + 5059 * v.second.w , seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec3PairVec2Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.first.z +
|
|
5021 * v.first.second.x + 5023 * v.first.second.y + 5039 * v.first.second.z +
|
|
5051 * v.second.first.x + 5059 * v.second.first.y +
|
|
5077 * v.second.second.x + 5081 * v.second.second.y, seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec3PairVec4& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.first.z +
|
|
5021 * v.first.second.x + 5023 * v.first.second.y + 5039 * v.first.second.z +
|
|
5051 * v.second.x + 5059 * v.second.y + 5077 * v.second.z + 5081 * v.second.w, seed);
|
|
}
|
|
|
|
|
|
inline uint qHash(const Vec3PairVec4Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.first.z
|
|
+ 5023 * v.first.second.x + 5039 * v.first.second.y + 5051 * v.first.second.z
|
|
+ 5077 * v.second.first.x + 5081 * v.second.first.y + 5087 * v.second.first.z + 5099 * v.second.first.w
|
|
+ 5101 * v.second.second.x + 5107 * v.second.second.y + 5113 * v.second.second.z + 5119 * v.second.second.w,
|
|
seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec4PairVec4& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.first.z + 5021 * v.first.first.w
|
|
+ 5023 * v.first.second.x + 5039 * v.first.second.y + 5051 * v.first.second.z + 5059 * v.first.second.w
|
|
+ 5077 * v.second.x + 5081 * v.second.y + 5087 * v.second.z + 5099 * v.second.w,
|
|
seed);
|
|
}
|
|
|
|
inline uint qHash(const Vec4PairVec4Pair& v, uint seed) {
|
|
// multiply by prime numbers greater than the possible size
|
|
return qHash(v.first.first.x + 5009 * v.first.first.y + 5011 * v.first.first.z + 5021 * v.first.first.w
|
|
+ 5023 * v.first.second.x + 5039 * v.first.second.y + 5051 * v.first.second.z + 5059 * v.first.second.w
|
|
+ 5077 * v.second.first.x + 5081 * v.second.first.y + 5087 * v.second.first.z + 5099 * v.second.first.w
|
|
+ 5101 * v.second.second.x + 5107 * v.second.second.y + 5113 * v.second.second.z + 5119 * v.second.second.w,
|
|
seed);
|
|
}
|
|
|
|
/// Stores cached geometry.
|
|
class GeometryCache : public Dependency {
|
|
SINGLETON_DEPENDENCY
|
|
|
|
public:
|
|
enum Shape {
|
|
Line,
|
|
Triangle,
|
|
Quad,
|
|
Hexagon,
|
|
Octagon,
|
|
Circle,
|
|
Cube,
|
|
Sphere,
|
|
Tetrahedron,
|
|
Octahedron,
|
|
Dodecahedron,
|
|
Icosahedron,
|
|
Torus, // not yet implemented
|
|
Cone,
|
|
Cylinder,
|
|
NUM_SHAPES,
|
|
};
|
|
|
|
/// @param entityShapeEnum: The entity::Shape enumeration for the shape
|
|
/// whose GeometryCache::Shape is desired.
|
|
/// @return GeometryCache::NUM_SHAPES in the event of an error; otherwise,
|
|
/// the GeometryCache::Shape enum which aligns with the
|
|
/// specified entityShapeEnum
|
|
static GeometryCache::Shape getShapeForEntityShape(int entityShapeEnum);
|
|
static QString stringFromShape(GeometryCache::Shape geoShape);
|
|
|
|
static void computeSimpleHullPointListForShape(int entityShape, const glm::vec3 &entityExtents, QVector<glm::vec3> &outPointList);
|
|
|
|
static uint8_t CUSTOM_PIPELINE_NUMBER;
|
|
static render::ShapePipelinePointer shapePipelineFactory(const render::ShapePlumber& plumber, const render::ShapeKey& key, gpu::Batch& batch);
|
|
static void registerShapePipeline() {
|
|
if (!CUSTOM_PIPELINE_NUMBER) {
|
|
CUSTOM_PIPELINE_NUMBER = render::ShapePipeline::registerCustomShapePipelineFactory(shapePipelineFactory);
|
|
}
|
|
}
|
|
|
|
int allocateID() { return _nextID++; }
|
|
void releaseID(int id);
|
|
static const int UNKNOWN_ID;
|
|
|
|
// Bind the pipeline and get the state to render static geometry
|
|
void bindSimpleProgram(gpu::Batch& batch, bool textured = false, bool transparent = false, bool culled = true,
|
|
bool unlit = false, bool depthBias = false, bool isAntiAliased = true, bool forward = false);
|
|
// Get the pipeline to render static geometry
|
|
static gpu::PipelinePointer getSimplePipeline(bool textured = false, bool transparent = false, bool culled = true,
|
|
bool unlit = false, bool depthBias = false, bool fading = false, bool isAntiAliased = true, bool forward = false);
|
|
|
|
void bindWebBrowserProgram(gpu::Batch& batch, bool transparent = false);
|
|
gpu::PipelinePointer getWebBrowserProgram(bool transparent);
|
|
|
|
static void initializeShapePipelines();
|
|
|
|
render::ShapePipelinePointer getOpaqueShapePipeline() { assert(_simpleOpaquePipeline != nullptr); return _simpleOpaquePipeline; }
|
|
render::ShapePipelinePointer getTransparentShapePipeline() { assert(_simpleTransparentPipeline != nullptr); return _simpleTransparentPipeline; }
|
|
render::ShapePipelinePointer getForwardOpaqueShapePipeline() { assert(_forwardSimpleOpaquePipeline != nullptr); return _forwardSimpleOpaquePipeline; }
|
|
render::ShapePipelinePointer getForwardTransparentShapePipeline() { assert(_forwardSimpleTransparentPipeline != nullptr); return _forwardSimpleTransparentPipeline; }
|
|
|
|
// Static (instanced) geometry
|
|
void renderShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
|
|
void renderWireShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
|
|
|
|
void renderFadeShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer,
|
|
gpu::BufferPointer& fadeBuffer1, gpu::BufferPointer& fadeBuffer2, gpu::BufferPointer& fadeBuffer3);
|
|
void renderWireFadeShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer,
|
|
gpu::BufferPointer& fadeBuffer1, gpu::BufferPointer& fadeBuffer2, gpu::BufferPointer& fadeBuffer3);
|
|
|
|
void renderSolidShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color = glm::vec4(1),
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline);
|
|
void renderSolidShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline) {
|
|
renderSolidShapeInstance(args, batch, shape, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
void renderWireShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color = glm::vec4(1),
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline);
|
|
void renderWireShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline) {
|
|
renderWireShapeInstance(args, batch, shape, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
void renderSolidFadeShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color, int fadeCategory, float fadeThreshold,
|
|
const glm::vec3& fadeNoiseOffset, const glm::vec3& fadeBaseOffset, const glm::vec3& fadeBaseInvSize,
|
|
const render::ShapePipelinePointer& pipeline);
|
|
void renderWireFadeShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color, int fadeCategory, float fadeThreshold,
|
|
const glm::vec3& fadeNoiseOffset, const glm::vec3& fadeBaseOffset, const glm::vec3& fadeBaseInvSize,
|
|
const render::ShapePipelinePointer& pipeline);
|
|
|
|
void renderSolidSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline);
|
|
void renderSolidSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline) {
|
|
renderSolidSphereInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
void renderWireSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleWirePipeline);
|
|
void renderWireSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleWirePipeline) {
|
|
renderWireSphereInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
void renderSolidCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline);
|
|
void renderSolidCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleOpaquePipeline) {
|
|
renderSolidCubeInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
void renderWireCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleWirePipeline);
|
|
void renderWireCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
|
|
const render::ShapePipelinePointer& pipeline = _simpleWirePipeline) {
|
|
renderWireCubeInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
|
|
}
|
|
|
|
// Dynamic geometry
|
|
void renderShape(gpu::Batch& batch, Shape shape);
|
|
void renderWireShape(gpu::Batch& batch, Shape shape);
|
|
void renderShape(gpu::Batch& batch, Shape shape, const glm::vec4& color);
|
|
void renderWireShape(gpu::Batch& batch, Shape shape, const glm::vec4& color);
|
|
size_t getShapeTriangleCount(Shape shape);
|
|
|
|
void renderCube(gpu::Batch& batch);
|
|
void renderWireCube(gpu::Batch& batch);
|
|
void renderCube(gpu::Batch& batch, const glm::vec4& color);
|
|
void renderWireCube(gpu::Batch& batch, const glm::vec4& color);
|
|
size_t getCubeTriangleCount();
|
|
|
|
void renderSphere(gpu::Batch& batch);
|
|
void renderWireSphere(gpu::Batch& batch);
|
|
void renderSphere(gpu::Batch& batch, const glm::vec4& color);
|
|
void renderWireSphere(gpu::Batch& batch, const glm::vec4& color);
|
|
size_t getSphereTriangleCount();
|
|
|
|
void renderGrid(gpu::Batch& batch, const glm::vec2& minCorner, const glm::vec2& maxCorner,
|
|
int majorRows, int majorCols, float majorEdge,
|
|
int minorRows, int minorCols, float minorEdge,
|
|
const glm::vec4& color, bool forward, int id);
|
|
|
|
void renderBevelCornersRect(gpu::Batch& batch, int x, int y, int width, int height, int bevelDistance, const glm::vec4& color, int id);
|
|
|
|
void renderUnitQuad(gpu::Batch& batch, const glm::vec4& color, int id);
|
|
|
|
void renderUnitQuad(gpu::Batch& batch, int id) {
|
|
renderUnitQuad(batch, glm::vec4(1), id);
|
|
}
|
|
|
|
void renderQuad(gpu::Batch& batch, int x, int y, int width, int height, const glm::vec4& color, int id)
|
|
{ renderQuad(batch, glm::vec2(x,y), glm::vec2(x + width, y + height), color, id); }
|
|
|
|
// TODO: I think there's a bug in this version of the renderQuad() that's not correctly rebuilding the vbos
|
|
// if the color changes by the corners are the same, as evidenced by the audio meter which should turn white
|
|
// when it's clipping
|
|
void renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, const glm::vec2& maxCorner, const glm::vec4& color, int id);
|
|
|
|
void renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, const glm::vec2& maxCorner,
|
|
const glm::vec2& texCoordMinCorner, const glm::vec2& texCoordMaxCorner,
|
|
const glm::vec4& color, int id);
|
|
|
|
void renderQuad(gpu::Batch& batch, const glm::vec3& minCorner, const glm::vec3& maxCorner, const glm::vec4& color, int id);
|
|
|
|
void renderQuad(gpu::Batch& batch, const glm::vec3& topLeft, const glm::vec3& bottomLeft,
|
|
const glm::vec3& bottomRight, const glm::vec3& topRight,
|
|
const glm::vec2& texCoordTopLeft, const glm::vec2& texCoordBottomLeft,
|
|
const glm::vec2& texCoordBottomRight, const glm::vec2& texCoordTopRight,
|
|
const glm::vec4& color, int id);
|
|
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2, const glm::vec3& color, int id)
|
|
{ renderLine(batch, p1, p2, color, color, id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
|
|
const glm::vec3& color1, const glm::vec3& color2, int id)
|
|
{ renderLine(batch, p1, p2, glm::vec4(color1, 1.0f), glm::vec4(color2, 1.0f), id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
|
|
const glm::vec4& color, int id)
|
|
{ renderLine(batch, p1, p2, color, color, id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
|
|
const glm::vec4& color1, const glm::vec4& color2, int id);
|
|
|
|
void renderDashedLine(gpu::Batch& batch, const glm::vec3& start, const glm::vec3& end, const glm::vec4& color, int id)
|
|
{ renderDashedLine(batch, start, end, color, 0.05f, 0.025f, id); }
|
|
|
|
void renderDashedLine(gpu::Batch& batch, const glm::vec3& start, const glm::vec3& end, const glm::vec4& color,
|
|
const float dash_length, const float gap_length, int id);
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2, const glm::vec3& color, int id)
|
|
{ renderLine(batch, p1, p2, glm::vec4(color, 1.0f), id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2, const glm::vec4& color, int id)
|
|
{ renderLine(batch, p1, p2, color, color, id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2,
|
|
const glm::vec3& color1, const glm::vec3& color2, int id)
|
|
{ renderLine(batch, p1, p2, glm::vec4(color1, 1.0f), glm::vec4(color2, 1.0f), id); }
|
|
|
|
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2,
|
|
const glm::vec4& color1, const glm::vec4& color2, int id);
|
|
|
|
void updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color);
|
|
void updateVertices(int id, const QVector<glm::vec2>& points, const QVector<glm::vec4>& colors);
|
|
void updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color);
|
|
void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec4>& colors);
|
|
void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color);
|
|
void renderVertices(gpu::Batch& batch, gpu::Primitive primitiveType, int id);
|
|
|
|
/// Set a batch to the simple pipeline, returning the previous pipeline
|
|
void useSimpleDrawPipeline(gpu::Batch& batch, bool noBlend = false);
|
|
|
|
struct ShapeVertex {
|
|
ShapeVertex(const vec3& pos, const vec3& normal, const vec2& uv, const vec3& tangent) : pos(pos), normal(normal), uv(uv), tangent(tangent) {}
|
|
|
|
vec3 pos;
|
|
vec3 normal;
|
|
vec2 uv;
|
|
vec3 tangent;
|
|
};
|
|
|
|
struct ShapeData {
|
|
gpu::BufferView _positionView;
|
|
gpu::BufferView _normalView;
|
|
gpu::BufferView _texCoordView;
|
|
gpu::BufferView _tangentView;
|
|
gpu::BufferView _indicesView;
|
|
gpu::BufferView _wireIndicesView;
|
|
|
|
void setupVertices(gpu::BufferPointer& vertexBuffer, const std::vector<ShapeVertex>& vertices);
|
|
void setupIndices(gpu::BufferPointer& indexBuffer, const geometry::IndexVector& indices, const geometry::IndexVector& wireIndices);
|
|
void setupBatch(gpu::Batch& batch) const;
|
|
void draw(gpu::Batch& batch) const;
|
|
void drawWire(gpu::Batch& batch) const;
|
|
void drawInstances(gpu::Batch& batch, size_t count) const;
|
|
void drawWireInstances(gpu::Batch& batch, size_t count) const;
|
|
};
|
|
|
|
using VShape = std::array<ShapeData, NUM_SHAPES>;
|
|
|
|
/// returns ShapeData associated with the specified shape,
|
|
/// otherwise nullptr in the event of an error.
|
|
const ShapeData * getShapeData(Shape shape) const;
|
|
|
|
graphics::MeshPointer meshFromShape(Shape geometryShape, glm::vec3 color);
|
|
|
|
private:
|
|
|
|
GeometryCache();
|
|
virtual ~GeometryCache();
|
|
void buildShapes();
|
|
|
|
typedef QPair<int, int> IntPair;
|
|
typedef QPair<unsigned int, unsigned int> VerticesIndices;
|
|
|
|
|
|
VShape _shapes;
|
|
|
|
gpu::PipelinePointer _standardDrawPipeline;
|
|
gpu::PipelinePointer _standardDrawPipelineNoBlend;
|
|
|
|
gpu::BufferPointer _shapeVertices{ std::make_shared<gpu::Buffer>() };
|
|
gpu::BufferPointer _shapeIndices{ std::make_shared<gpu::Buffer>() };
|
|
|
|
class GridSchema {
|
|
public:
|
|
// data is arranged as majorRow, majorCol, minorRow, minorCol
|
|
glm::vec4 period;
|
|
glm::vec4 offset;
|
|
glm::vec4 edge;
|
|
};
|
|
using GridBuffer = gpu::BufferView;
|
|
void useGridPipeline(gpu::Batch& batch, GridBuffer gridBuffer, bool transparent, bool forward);
|
|
static std::map<std::pair<bool, bool>, gpu::PipelinePointer> _gridPipelines;
|
|
|
|
class BatchItemDetails {
|
|
public:
|
|
static int population;
|
|
gpu::BufferPointer verticesBuffer;
|
|
gpu::BufferPointer colorBuffer;
|
|
gpu::BufferPointer uniformBuffer;
|
|
gpu::Stream::FormatPointer streamFormat;
|
|
gpu::BufferStreamPointer stream;
|
|
|
|
int vertices;
|
|
int vertexSize;
|
|
bool isCreated;
|
|
|
|
BatchItemDetails();
|
|
BatchItemDetails(const GeometryCache::BatchItemDetails& other);
|
|
~BatchItemDetails();
|
|
void clear();
|
|
};
|
|
|
|
QHash<IntPair, VerticesIndices> _coneVBOs;
|
|
|
|
int _nextID{ 1 };
|
|
|
|
QHash<int, Vec3PairVec4Pair> _lastRegisteredQuad3DTexture;
|
|
QHash<int, BatchItemDetails> _registeredQuad3DTextures;
|
|
|
|
QHash<int, Vec4PairVec4> _lastRegisteredQuad2DTexture;
|
|
QHash<int, BatchItemDetails> _registeredQuad2DTextures;
|
|
|
|
QHash<int, Vec3PairVec4> _lastRegisteredQuad3D;
|
|
QHash<int, BatchItemDetails> _registeredQuad3D;
|
|
|
|
QHash<int, Vec4Pair> _lastRegisteredQuad2D;
|
|
QHash<int, BatchItemDetails> _registeredQuad2D;
|
|
|
|
QHash<int, Vec3Pair> _lastRegisteredBevelRects;
|
|
QHash<int, BatchItemDetails> _registeredBevelRects;
|
|
|
|
QHash<int, Vec3Pair> _lastRegisteredLine3D;
|
|
QHash<int, BatchItemDetails> _registeredLine3DVBOs;
|
|
|
|
QHash<int, Vec2Pair> _lastRegisteredLine2D;
|
|
QHash<int, BatchItemDetails> _registeredLine2DVBOs;
|
|
|
|
QHash<int, BatchItemDetails> _registeredVertices;
|
|
|
|
QHash<int, Vec3PairVec2Pair> _lastRegisteredDashedLines;
|
|
QHash<int, BatchItemDetails> _registeredDashedLines;
|
|
|
|
QHash<int, Vec2FloatPairPair> _lastRegisteredGridBuffer;
|
|
QHash<int, GridBuffer> _registeredGridBuffers;
|
|
|
|
// FIXME: clean these up
|
|
static gpu::ShaderPointer _simpleShader;
|
|
static gpu::ShaderPointer _transparentShader;
|
|
static gpu::ShaderPointer _unlitShader;
|
|
static gpu::ShaderPointer _simpleFadeShader;
|
|
static gpu::ShaderPointer _unlitFadeShader;
|
|
static gpu::ShaderPointer _forwardSimpleShader;
|
|
static gpu::ShaderPointer _forwardTransparentShader;
|
|
static gpu::ShaderPointer _forwardUnlitShader;
|
|
static gpu::ShaderPointer _forwardSimpleFadeShader;
|
|
static gpu::ShaderPointer _forwardUnlitFadeShader;
|
|
|
|
static render::ShapePipelinePointer _simpleOpaquePipeline;
|
|
static render::ShapePipelinePointer _simpleTransparentPipeline;
|
|
static render::ShapePipelinePointer _forwardSimpleOpaquePipeline;
|
|
static render::ShapePipelinePointer _forwardSimpleTransparentPipeline;
|
|
static render::ShapePipelinePointer _simpleOpaqueFadePipeline;
|
|
static render::ShapePipelinePointer _simpleTransparentFadePipeline;
|
|
static render::ShapePipelinePointer _simpleWirePipeline;
|
|
|
|
static QHash<SimpleProgramKey, gpu::PipelinePointer> _simplePrograms;
|
|
|
|
gpu::ShaderPointer _simpleOpaqueWebBrowserShader;
|
|
gpu::PipelinePointer _simpleOpaqueWebBrowserPipeline;
|
|
gpu::ShaderPointer _simpleTransparentWebBrowserShader;
|
|
gpu::PipelinePointer _simpleTransparentWebBrowserPipeline;
|
|
|
|
static render::ShapePipelinePointer getShapePipeline(bool textured = false, bool transparent = false, bool culled = true,
|
|
bool unlit = false, bool depthBias = false, bool forward = false);
|
|
static render::ShapePipelinePointer getFadingShapePipeline(bool textured = false, bool transparent = false, bool culled = true,
|
|
bool unlit = false, bool depthBias = false, bool forward = false);
|
|
};
|
|
|
|
#endif // hifi_GeometryCache_h
|