Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Scribe now outputs .h and .cpp. Need to change how shader source is referenced in C++ code

Browse source
This commit is contained in:
Olivier Prat 2018-01-16 19:02:12 +01:00
parent cdb94d0832
commit 3911ce59cc
36 changed files with 433 additions and 330 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
cmake/macros/AutoScribeShader.cmake
View file

@ -39,24 +39,28 @@ function(AUTOSCRIBE_SHADER SHADER_FILE)
get_filename_component(SHADER_TARGET ${SHADER_FILE} NAME_WE)
get_filename_component(SHADER_EXT ${SHADER_FILE} EXT)
if(SHADER_EXT STREQUAL .slv)
set(SHADER_TARGET ${SHADER_TARGET}_vert.cpp)
set(SHADER_TYPE vert)
elseif(${SHADER_EXT} STREQUAL .slf)
set(SHADER_TARGET ${SHADER_TARGET}_frag.cpp)
set(SHADER_TYPE frag)
elseif(${SHADER_EXT} STREQUAL .slg)
set(SHADER_TARGET ${SHADER_TARGET}_geom.cpp)
set(SHADER_TYPE geom)
endif()
set(SHADER_TARGET ${SHADER_TARGET}_${SHADER_TYPE})
set(SHADER_TARGET "${SHADERS_DIR}/${SHADER_TARGET}")
set(SHADER_TARGET_HEADER ${SHADER_TARGET}.h)
set(SHADER_TARGET_SOURCE ${SHADER_TARGET}.cpp)
# Target dependant Custom rule on the SHADER_FILE
if (APPLE)
set(GLPROFILE MAC_GL)
set(SCRIBE_ARGS -c++ -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
set(SCRIBE_ARGS -c++ -${SHADER_TYPE} -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET_HEADER} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe)
add_custom_command(OUTPUT ${SHADER_TARGET_SOURCE} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
elseif (ANDROID)
set(GLPROFILE LINUX_GL)
set(SCRIBE_ARGS -c++ -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
set(SCRIBE_ARGS -c++ -${SHADER_TYPE} -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
# for an android build, we can't use the scribe that cmake would normally produce as a target,
# since it's unrunnable by the cross-compiling build machine
@ -72,23 +76,25 @@ function(AUTOSCRIBE_SHADER SHADER_FILE)
")
endif ()
add_custom_command(OUTPUT ${SHADER_TARGET} COMMAND ${NATIVE_SCRIBE} ${SCRIBE_ARGS} DEPENDS ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET_HEADER} COMMAND ${NATIVE_SCRIBE} ${SCRIBE_ARGS})
add_custom_command(OUTPUT ${SHADER_TARGET_SOURCE} COMMAND ${NATIVE_SCRIBE} ${SCRIBE_ARGS} DEPENDS ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
elseif (UNIX)
set(GLPROFILE LINUX_GL)
set(SCRIBE_ARGS -c++ -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
set(SCRIBE_ARGS -c++ -${SHADER_TYPE} -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET_HEADER} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe)
add_custom_command(OUTPUT ${SHADER_TARGET_SOURCE} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
else ()
set(GLPROFILE PC_GL)
set(SCRIBE_ARGS -c++ -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
set(SCRIBE_ARGS -c++ -${SHADER_TYPE} -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
add_custom_command(OUTPUT ${SHADER_TARGET_HEADER} ${SHADER_TARGET_SOURCE} COMMAND scribe ${SCRIBE_ARGS} DEPENDS scribe ${SHADER_INCLUDE_FILES} ${SHADER_FILE})
endif()
#output the generated file name
set(AUTOSCRIBE_SHADER_RETURN ${SHADER_TARGET} PARENT_SCOPE)
set(AUTOSCRIBE_SHADER_RETURN ${SHADER_TARGET_HEADER} ${SHADER_TARGET_SOURCE} PARENT_SCOPE)
file(GLOB INCLUDE_FILES ${SHADER_TARGET})
file(GLOB INCLUDE_FILES ${SHADER_TARGET_HEADER})
endfunction()
@ -134,6 +140,9 @@ macro(AUTOSCRIBE_SHADER_LIB)
list(APPEND AUTOSCRIBE_SHADER_LIB_SRC ${AUTOSCRIBE_SHADER_SRC})
# Link library shaders, if they exist
#include_directories("${SHADERS_DIR}")
include_directories("${SHADERS_DIR}")
# Add search directory to find gpu/Shader.h
include_directories("${HIFI_LIBRARY_DIR}/gpu/src")
endmacro()

4
libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp
View file

@ -33,8 +33,8 @@
#include "../Logging.h"
#include "../CompositorHelper.h"
INCLUDE_SHADER(hmd_ui_vert)
INCLUDE_SHADER(hmd_ui_frag)
#include "hmd_ui_vert.h"
#include "hmd_ui_frag.h"
static const QString MONO_PREVIEW = "Mono Preview";
static const QString DISABLE_PREVIEW = "Disable Preview";

4
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
View file

@ -14,8 +14,8 @@
#include <GeometryCache.h>
INCLUDE_SHADER(textured_particle_vert)
INCLUDE_SHADER(textured_particle_frag)
#include "textured_particle_vert.h"
#include "textured_particle_frag.h"
using namespace render;
using namespace render::entities;

8
libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
View file

@ -23,11 +23,11 @@
# include <FadeEffect.h>
#endif
INCLUDE_SHADER(paintStroke_vert)
INCLUDE_SHADER(paintStroke_frag)
#include "paintStroke_vert.h"
#include "paintStroke_frag.h"
INCLUDE_SHADER(paintStroke_fade_vert)
INCLUDE_SHADER(paintStroke_fade_frag)
#include "paintStroke_fade_vert.h"
#include "paintStroke_fade_frag.h"
using namespace render;
using namespace render::entities;

16
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -28,10 +28,10 @@
#include "EntityTreeRenderer.h"
INCLUDE_SHADER(polyvox_vert)
INCLUDE_SHADER(polyvox_frag)
INCLUDE_SHADER(polyvox_fade_vert)
INCLUDE_SHADER(polyvox_fade_frag)
#include "polyvox_vert.h"
#include "polyvox_frag.h"
#include "polyvox_fade_vert.h"
#include "polyvox_fade_frag.h"
#ifdef POLYVOX_ENTITY_USE_FADE_EFFECT
# include <FadeEffect.h>
@ -72,10 +72,10 @@ INCLUDE_SHADER(polyvox_fade_frag)
#include "EntityTreeRenderer.h"
INCLUDE_SHADER(polyvox_vert)
INCLUDE_SHADER(polyvox_frag)
INCLUDE_SHADER(polyvox_fade_vert)
INCLUDE_SHADER(polyvox_fade_frag)
#include "polyvox_vert.h"
#include "polyvox_frag.h"
#include "polyvox_fade_vert.h"
#include "polyvox_fade_frag.h"
#include "RenderablePolyVoxEntityItem.h"
#include "EntityEditPacketSender.h"

4
libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
View file

@ -16,8 +16,8 @@
#include <GeometryCache.h>
#include <PerfStat.h>
INCLUDE_SHADER(simple_vert)
INCLUDE_SHADER(simple_frag)
#include "simple_vert.h"
#include "simple_frag.h"
//#define SHAPE_ENTITY_USE_FADE_EFFECT
#ifdef SHAPE_ENTITY_USE_FADE_EFFECT

2
libraries/gpu/src/gpu/Shader.h
View file

@ -17,8 +17,6 @@
#include <set>
#include <QUrl>
#define INCLUDE_SHADER(source) extern const char source[];
namespace gpu {

48
libraries/gpu/src/gpu/StandardShaderLib.cpp
View file

@ -12,21 +12,21 @@
//
#include "StandardShaderLib.h"
INCLUDE_SHADER(DrawUnitQuadTexcoord_vert)
INCLUDE_SHADER(DrawTransformUnitQuad_vert)
INCLUDE_SHADER(DrawTexcoordRectTransformUnitQuad_vert)
INCLUDE_SHADER(DrawViewportQuadTransformTexcoord_vert)
INCLUDE_SHADER(DrawVertexPosition_vert)
INCLUDE_SHADER(DrawTransformVertexPosition_vert)
#include "DrawUnitQuadTexcoord_vert.h"
#include "DrawTransformUnitQuad_vert.h"
#include "DrawTexcoordRectTransformUnitQuad_vert.h"
#include "DrawViewportQuadTransformTexcoord_vert.h"
#include "DrawVertexPosition_vert.h"
#include "DrawTransformVertexPosition_vert.h"
const char DrawNada_frag[] = "void main(void) {}"; // DrawNada is really simple...
INCLUDE_SHADER(DrawWhite_frag)
INCLUDE_SHADER(DrawColor_frag)
INCLUDE_SHADER(DrawTexture_frag)
INCLUDE_SHADER(DrawTextureMirroredX_frag)
INCLUDE_SHADER(DrawTextureOpaque_frag)
INCLUDE_SHADER(DrawColoredTexture_frag)
#include "DrawWhite_frag.h"
#include "DrawColor_frag.h"
#include "DrawTexture_frag.h"
#include "DrawTextureMirroredX_frag.h"
#include "DrawTextureOpaque_frag.h"
#include "DrawColoredTexture_frag.h"
using namespace gpu;
@ -73,42 +73,42 @@ ShaderPointer StandardShaderLib::getProgram(GetShader getVS, GetShader getPS) {
ShaderPointer StandardShaderLib::getDrawUnitQuadTexcoordVS() {
if (!_drawUnitQuadTexcoordVS) {
_drawUnitQuadTexcoordVS = gpu::Shader::createVertex(std::string(DrawUnitQuadTexcoord_vert));
_drawUnitQuadTexcoordVS = DrawUnitQuadTexcoord_vert::getShader();
}
return _drawUnitQuadTexcoordVS;
}
ShaderPointer StandardShaderLib::getDrawTransformUnitQuadVS() {
if (!_drawTransformUnitQuadVS) {
_drawTransformUnitQuadVS = gpu::Shader::createVertex(std::string(DrawTransformUnitQuad_vert));
_drawTransformUnitQuadVS = DrawTransformUnitQuad_vert::getShader();
}
return _drawTransformUnitQuadVS;
}
ShaderPointer StandardShaderLib::getDrawTexcoordRectTransformUnitQuadVS() {
if (!_drawTexcoordRectTransformUnitQuadVS) {
_drawTexcoordRectTransformUnitQuadVS = gpu::Shader::createVertex(std::string(DrawTexcoordRectTransformUnitQuad_vert));
_drawTexcoordRectTransformUnitQuadVS = DrawTexcoordRectTransformUnitQuad_vert::getShader();
}
return _drawTexcoordRectTransformUnitQuadVS;
}
ShaderPointer StandardShaderLib::getDrawViewportQuadTransformTexcoordVS() {
if (!_drawViewportQuadTransformTexcoordVS) {
_drawViewportQuadTransformTexcoordVS = gpu::Shader::createVertex(std::string(DrawViewportQuadTransformTexcoord_vert));
_drawViewportQuadTransformTexcoordVS = DrawViewportQuadTransformTexcoord_vert::getShader();
}
return _drawViewportQuadTransformTexcoordVS;
}
ShaderPointer StandardShaderLib::getDrawVertexPositionVS() {
if (!_drawVertexPositionVS) {
_drawVertexPositionVS = gpu::Shader::createVertex(std::string(DrawVertexPosition_vert));
_drawVertexPositionVS = DrawVertexPosition_vert::getShader();
}
return _drawVertexPositionVS;
}
ShaderPointer StandardShaderLib::getDrawTransformVertexPositionVS() {
if (!_drawTransformVertexPositionVS) {
_drawTransformVertexPositionVS = gpu::Shader::createVertex(std::string(DrawTransformVertexPosition_vert));
_drawTransformVertexPositionVS = DrawTransformVertexPosition_vert::getShader();
}
return _drawTransformVertexPositionVS;
}
@ -122,42 +122,42 @@ ShaderPointer StandardShaderLib::getDrawNadaPS() {
ShaderPointer StandardShaderLib::getDrawWhitePS() {
if (!_drawWhitePS) {
_drawWhitePS = gpu::Shader::createPixel(std::string(DrawWhite_frag));
_drawWhitePS = DrawWhite_frag::getShader();
}
return _drawWhitePS;
}
ShaderPointer StandardShaderLib::getDrawColorPS() {
if (!_drawColorPS) {
_drawColorPS = gpu::Shader::createPixel(std::string(DrawColor_frag));
_drawColorPS = DrawColor_frag::getShader();
}
return _drawColorPS;
}
ShaderPointer StandardShaderLib::getDrawTexturePS() {
if (!_drawTexturePS) {
_drawTexturePS = gpu::Shader::createPixel(std::string(DrawTexture_frag));
_drawTexturePS = DrawTexture_frag::getShader();
}
return _drawTexturePS;
}
ShaderPointer StandardShaderLib::getDrawTextureMirroredXPS() {
if (!_drawTextureMirroredXPS) {
_drawTextureMirroredXPS = gpu::Shader::createPixel(std::string(DrawTextureMirroredX_frag));
_drawTextureMirroredXPS = DrawTextureMirroredX_frag::getShader();
}
return _drawTextureMirroredXPS;
}
ShaderPointer StandardShaderLib::getDrawTextureOpaquePS() {
if (!_drawTextureOpaquePS) {
_drawTextureOpaquePS = gpu::Shader::createPixel(std::string(DrawTextureOpaque_frag));
_drawTextureOpaquePS = DrawTextureOpaque_frag::getShader();
}
return _drawTextureOpaquePS;
}
ShaderPointer StandardShaderLib::getDrawColoredTexturePS() {
if (!_drawColoredTexturePS) {
_drawColoredTexturePS = gpu::Shader::createPixel(std::string(DrawColoredTexture_frag));
_drawColoredTexturePS = DrawColoredTexture_frag::getShader();
}
return _drawColoredTexturePS;
}

8
libraries/model/src/model/Skybox.cpp
View file

@ -15,8 +15,8 @@
#include <gpu/Context.h>
#include <ViewFrustum.h>
INCLUDE_SHADER(skybox_vert)
INCLUDE_SHADER(skybox_frag)
#include "skybox_vert.h"
#include "skybox_frag.h"
using namespace model;
@ -85,8 +85,8 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
static std::once_flag once;
std::call_once(once, [&] {
{
auto skyVS = gpu::Shader::createVertex(std::string(skybox_vert));
auto skyFS = gpu::Shader::createPixel(std::string(skybox_frag));
auto skyVS = skybox_vert::getShader();
auto skyFS = skybox_frag::getShader();
auto skyShader = gpu::Shader::createProgram(skyVS, skyFS);
gpu::Shader::BindingSet bindings;

4
libraries/procedural/src/procedural/Procedural.cpp
View file

@ -20,7 +20,7 @@
#include <NumericalConstants.h>
#include <GLMHelpers.h>
INCLUDE_SHADER(ProceduralCommon_frag)
#include "ProceduralCommon_frag.h"
#include "Logging.h"
@ -241,7 +241,7 @@ void Procedural::prepare(gpu::Batch& batch, const glm::vec3& position, const glm
std::string fragmentShaderSource = _fragmentSource;
size_t replaceIndex = fragmentShaderSource.find(PROCEDURAL_COMMON_BLOCK);
if (replaceIndex != std::string::npos) {
fragmentShaderSource.replace(replaceIndex, PROCEDURAL_COMMON_BLOCK.size(), ProceduralCommon_frag);
fragmentShaderSource.replace(replaceIndex, PROCEDURAL_COMMON_BLOCK.size(), ProceduralCommon_frag.h";
}
replaceIndex = fragmentShaderSource.find(PROCEDURAL_VERSION);

4
libraries/procedural/src/procedural/ProceduralSkybox.cpp
View file

@ -15,8 +15,8 @@
#include <gpu/Context.h>
#include <ViewFrustum.h>
INCLUDE_SHADER(skybox_vert)
INCLUDE_SHADER(skybox_frag)
#include "skybox_vert.h"
#include "skybox_frag.h"
ProceduralSkybox::ProceduralSkybox() : model::Skybox() {
_procedural._vertexSource = skybox_vert;

10
libraries/render-utils/src/AmbientOcclusionEffect.cpp
View file

@ -28,11 +28,11 @@
#include "DependencyManager.h"
#include "ViewFrustum.h"
INCLUDE_SHADER(ssao_makePyramid_frag)
INCLUDE_SHADER(ssao_makeOcclusion_frag)
INCLUDE_SHADER(ssao_debugOcclusion_frag)
INCLUDE_SHADER(ssao_makeHorizontalBlur_frag)
INCLUDE_SHADER(ssao_makeVerticalBlur_frag)
#include "ssao_makePyramid_frag.h"
#include "ssao_makeOcclusion_frag.h"
#include "ssao_debugOcclusion_frag.h"
#include "ssao_makeHorizontalBlur_frag.h"
#include "ssao_makeVerticalBlur_frag.h"
AmbientOcclusionFramebuffer::AmbientOcclusionFramebuffer() {

4
libraries/render-utils/src/AnimDebugDraw.cpp
View file

@ -17,8 +17,8 @@
#include "AnimDebugDraw.h"
INCLUDE_SHADER(animdebugdraw_vert)
INCLUDE_SHADER(animdebugdraw_frag)
#include "animdebugdraw_vert.h"
#include "animdebugdraw_frag.h"
class AnimDebugDrawData {
public:

6
libraries/render-utils/src/AntialiasingEffect.cpp
View file

@ -23,9 +23,9 @@
#include "ViewFrustum.h"
#include "GeometryCache.h"
INCLUDE_SHADER(fxaa_vert)
INCLUDE_SHADER(fxaa_frag)
INCLUDE_SHADER(fxaa_blend_frag)
#include "fxaa_vert.h"
#include "fxaa_frag.h"
#include "fxaa_blend_frag.h"
Antialiasing::Antialiasing() {

4
libraries/render-utils/src/BloomEffect.cpp
View file

@ -16,8 +16,8 @@
#include <render/BlurTask.h>
#include <render/ResampleTask.h>
INCLUDE_SHADER(BloomThreshold_frag)
INCLUDE_SHADER(BloomApply_frag)
#include "BloomThreshold_frag.h"
#include "BloomApply_frag.h"
#define BLOOM_BLUR_LEVEL_COUNT 3

4
libraries/render-utils/src/DebugDeferredBuffer.cpp
View file

@ -23,8 +23,8 @@
#include "TextureCache.h"
#include "DeferredLightingEffect.h"
INCLUDE_SHADER(debug_deferred_buffer_vert)
INCLUDE_SHADER(debug_deferred_buffer_frag)
#include "debug_deferred_buffer_vert.h"
#include "debug_deferred_buffer_frag.h"
using namespace render;

18
libraries/render-utils/src/DeferredLightingEffect.cpp
View file

@ -24,18 +24,18 @@
#include "TextureCache.h"
#include "FramebufferCache.h"
INCLUDE_SHADER(deferred_light_vert)
INCLUDE_SHADER(deferred_light_point_vert)
INCLUDE_SHADER(deferred_light_spot_vert)
#include "deferred_light_vert.h"
#include "deferred_light_point_vert.h"
#include "deferred_light_spot_vert.h"
INCLUDE_SHADER(directional_ambient_light_frag)
INCLUDE_SHADER(directional_skybox_light_frag)
#include "directional_ambient_light_frag.h"
#include "directional_skybox_light_frag.h"
INCLUDE_SHADER(directional_ambient_light_shadow_frag)
INCLUDE_SHADER(directional_skybox_light_shadow_frag)
#include "directional_ambient_light_shadow_frag.h"
#include "directional_skybox_light_shadow_frag.h"
INCLUDE_SHADER(local_lights_shading_frag)
INCLUDE_SHADER(local_lights_drawOutline_frag)
#include "local_lights_shading_frag.h"
#include "local_lights_drawOutline_frag.h"
using namespace render;

2
libraries/render-utils/src/DrawHaze.cpp
View file

@ -19,7 +19,7 @@
#include "HazeStage.h"
#include "LightStage.h"
INCLUDE_SHADER(Haze_frag)
#include "Haze_frag.h"
void HazeConfig::setHazeColor(const glm::vec3 value) {
hazeColor = value;

26
libraries/render-utils/src/GeometryCache.cpp
View file

@ -34,21 +34,21 @@
#include "model/TextureMap.h"
#include "render/Args.h"
INCLUDE_SHADER(standardTransformPNTC_vert)
INCLUDE_SHADER(standardDrawTexture_frag)
#include "standardTransformPNTC_vert.h"
#include "standardDrawTexture_frag.h"
INCLUDE_SHADER(simple_vert)
INCLUDE_SHADER(simple_textured_frag)
INCLUDE_SHADER(simple_textured_unlit_frag)
INCLUDE_SHADER(simple_fade_vert)
INCLUDE_SHADER(simple_textured_fade_frag)
INCLUDE_SHADER(simple_textured_unlit_fade_frag)
INCLUDE_SHADER(simple_opaque_web_browser_frag)
INCLUDE_SHADER(simple_transparent_web_browser_frag)
INCLUDE_SHADER(glowLine_vert)
INCLUDE_SHADER(glowLine_frag)
#include "simple_vert.h"
#include "simple_textured_frag.h"
#include "simple_textured_unlit_frag.h"
#include "simple_fade_vert.h"
#include "simple_textured_fade_frag.h"
#include "simple_textured_unlit_fade_frag.h"
#include "simple_opaque_web_browser_frag.h"
#include "simple_transparent_web_browser_frag.h"
#include "glowLine_vert.h"
#include "glowLine_frag.h"
INCLUDE_SHADER(grid_frag)
#include "grid_frag.h"
//#define WANT_DEBUG

20
libraries/render-utils/src/HighlightEffect.cpp
View file

@ -22,13 +22,13 @@
#include <sstream>
INCLUDE_SHADER(surfaceGeometry_copyDepth_frag)
INCLUDE_SHADER(debug_deferred_buffer_vert)
INCLUDE_SHADER(debug_deferred_buffer_frag)
INCLUDE_SHADER(Highlight_frag)
INCLUDE_SHADER(Highlight_filled_frag)
INCLUDE_SHADER(Highlight_aabox_vert)
INCLUDE_SHADER(nop_frag)
#include "surfaceGeometry_copyDepth_frag.h"
#include "debug_deferred_buffer_vert.h"
#include "debug_deferred_buffer_frag.h"
#include "Highlight_frag.h"
#include "Highlight_filled_frag.h"
#include "Highlight_aabox_vert.h"
#include "nop_frag.h"
using namespace render;
@ -547,10 +547,10 @@ const render::Varying DrawHighlightTask::addSelectItemJobs(JobModel& task, const
return task.addJob<SelectItems>("TransparentSelection", selectItemInput);
}
INCLUDE_SHADER(model_shadow_vert)
INCLUDE_SHADER(skin_model_shadow_vert)
#include "model_shadow_vert.h"
#include "skin_model_shadow_vert.h"
INCLUDE_SHADER(model_shadow_frag)
#include "model_shadow_frag.h"
void DrawHighlightTask::initMaskPipelines(render::ShapePlumber& shapePlumber, gpu::StatePointer state) {
auto modelVertex = gpu::Shader::createVertex(std::string(model_shadow_vert));

12
libraries/render-utils/src/LightClusters.cpp
View file

@ -18,15 +18,15 @@
#include "StencilMaskPass.h"
INCLUDE_SHADER(lightClusters_drawGrid_vert)
INCLUDE_SHADER(lightClusters_drawGrid_frag)
#include "lightClusters_drawGrid_vert.h"
#include "lightClusters_drawGrid_frag.h"
//INCLUDE_SHADER(lightClusters_drawClusterFromDepth_vert)
INCLUDE_SHADER(lightClusters_drawClusterFromDepth_frag)
//#include "lightClusters_drawClusterFromDepth_vert.h"
#include "lightClusters_drawClusterFromDepth_frag.h"
INCLUDE_SHADER(lightClusters_drawClusterContent_vert)
INCLUDE_SHADER(lightClusters_drawClusterContent_frag)
#include "lightClusters_drawClusterContent_vert.h"
#include "lightClusters_drawClusterContent_frag.h"
enum LightClusterGridShader_MapSlot {
DEFERRED_BUFFER_LINEAR_DEPTH_UNIT = 0,

4
libraries/render-utils/src/RenderForwardTask.cpp
View file

@ -24,7 +24,7 @@
#include <gpu/StandardShaderLib.h>
INCLUDE_SHADER(nop_frag)
#include "nop_frag.h"
using namespace render;
extern void initForwardPipelines(ShapePlumber& plumber);
@ -125,7 +125,7 @@ void Draw::run(const RenderContextPointer& renderContext,
const gpu::PipelinePointer Stencil::getPipeline() {
if (!_stencilPipeline) {
auto vs = gpu::StandardShaderLib::getDrawUnitQuadTexcoordVS();
auto ps = gpu::Shader::createPixel(std::string(nop_frag));
auto ps = gpu::Shader::createPixel(std::string(nop_frag);
gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
gpu::Shader::makeProgram(*program);

132
libraries/render-utils/src/RenderPipelines.cpp
View file

@ -20,86 +20,86 @@
#include "TextureCache.h"
#include "render/DrawTask.h"
INCLUDE_SHADER(model_vert)
INCLUDE_SHADER(model_normal_map_vert)
INCLUDE_SHADER(model_lightmap_vert)
INCLUDE_SHADER(model_lightmap_normal_map_vert)
INCLUDE_SHADER(skin_model_vert)
INCLUDE_SHADER(skin_model_normal_map_vert)
#include "model_vert.h"
#include "model_normal_map_vert.h"
#include "model_lightmap_vert.h"
#include "model_lightmap_normal_map_vert.h"
#include "skin_model_vert.h"
#include "skin_model_normal_map_vert.h"
INCLUDE_SHADER(model_lightmap_fade_vert)
INCLUDE_SHADER(model_lightmap_normal_map_fade_vert)
INCLUDE_SHADER(skin_model_fade_vert)
INCLUDE_SHADER(skin_model_normal_map_fade_vert)
#include "model_lightmap_fade_vert.h"
#include "model_lightmap_normal_map_fade_vert.h"
#include "skin_model_fade_vert.h"
#include "skin_model_normal_map_fade_vert.h"
INCLUDE_SHADER(simple_vert)
INCLUDE_SHADER(simple_textured_frag)
INCLUDE_SHADER(simple_textured_unlit_frag)
INCLUDE_SHADER(simple_transparent_textured_frag)
INCLUDE_SHADER(simple_transparent_textured_unlit_frag)
#include "simple_vert.h"
#include "simple_textured_frag.h"
#include "simple_textured_unlit_frag.h"
#include "simple_transparent_textured_frag.h"
#include "simple_transparent_textured_unlit_frag.h"
INCLUDE_SHADER(simple_fade_vert)
INCLUDE_SHADER(simple_textured_fade_frag)
INCLUDE_SHADER(simple_textured_unlit_fade_frag)
INCLUDE_SHADER(simple_transparent_textured_fade_frag)
INCLUDE_SHADER(simple_transparent_textured_unlit_fade_frag)
#include "simple_fade_vert.h"
#include "simple_textured_fade_frag.h"
#include "simple_textured_unlit_fade_frag.h"
#include "simple_transparent_textured_fade_frag.h"
#include "simple_transparent_textured_unlit_fade_frag.h"
INCLUDE_SHADER(model_frag)
INCLUDE_SHADER(model_unlit_frag)
INCLUDE_SHADER(model_normal_map_frag)
INCLUDE_SHADER(model_normal_specular_map_frag)
INCLUDE_SHADER(model_specular_map_frag)
#include "model_frag.h"
#include "model_unlit_frag.h"
#include "model_normal_map_frag.h"
#include "model_normal_specular_map_frag.h"
#include "model_specular_map_frag.h"
INCLUDE_SHADER(model_fade_vert)
INCLUDE_SHADER(model_normal_map_fade_vert)
#include "model_fade_vert.h"
#include "model_normal_map_fade_vert.h"
INCLUDE_SHADER(model_fade_frag)
INCLUDE_SHADER(model_unlit_fade_frag)
INCLUDE_SHADER(model_normal_map_fade_frag)
INCLUDE_SHADER(model_normal_specular_map_fade_frag)
INCLUDE_SHADER(model_specular_map_fade_frag)
#include "model_fade_frag.h"
#include "model_unlit_fade_frag.h"
#include "model_normal_map_fade_frag.h"
#include "model_normal_specular_map_fade_frag.h"
#include "model_specular_map_fade_frag.h"
INCLUDE_SHADER(forward_model_frag)
INCLUDE_SHADER(forward_model_unlit_frag)
INCLUDE_SHADER(forward_model_normal_map_frag)
INCLUDE_SHADER(forward_model_normal_specular_map_frag)
INCLUDE_SHADER(forward_model_specular_map_frag)
#include "forward_model_frag.h"
#include "forward_model_unlit_frag.h"
#include "forward_model_normal_map_frag.h"
#include "forward_model_normal_specular_map_frag.h"
#include "forward_model_specular_map_frag.h"
INCLUDE_SHADER(model_lightmap_frag)
INCLUDE_SHADER(model_lightmap_normal_map_frag)
INCLUDE_SHADER(model_lightmap_normal_specular_map_frag)
INCLUDE_SHADER(model_lightmap_specular_map_frag)
INCLUDE_SHADER(model_translucent_frag)
INCLUDE_SHADER(model_translucent_unlit_frag)
#include "model_lightmap_frag.h"
#include "model_lightmap_normal_map_frag.h"
#include "model_lightmap_normal_specular_map_frag.h"
#include "model_lightmap_specular_map_frag.h"
#include "model_translucent_frag.h"
#include "model_translucent_unlit_frag.h"
INCLUDE_SHADER(model_lightmap_fade_frag)
INCLUDE_SHADER(model_lightmap_normal_map_fade_frag)
INCLUDE_SHADER(model_lightmap_normal_specular_map_fade_frag)
INCLUDE_SHADER(model_lightmap_specular_map_fade_frag)
INCLUDE_SHADER(model_translucent_fade_frag)
INCLUDE_SHADER(model_translucent_unlit_fade_frag)
#include "model_lightmap_fade_frag.h"
#include "model_lightmap_normal_map_fade_frag.h"
#include "model_lightmap_normal_specular_map_fade_frag.h"
#include "model_lightmap_specular_map_fade_frag.h"
#include "model_translucent_fade_frag.h"
#include "model_translucent_unlit_fade_frag.h"
INCLUDE_SHADER(overlay3D_vert)
INCLUDE_SHADER(overlay3D_frag)
INCLUDE_SHADER(overlay3D_model_frag)
INCLUDE_SHADER(overlay3D_model_translucent_frag)
INCLUDE_SHADER(overlay3D_translucent_frag)
INCLUDE_SHADER(overlay3D_unlit_frag)
INCLUDE_SHADER(overlay3D_translucent_unlit_frag)
INCLUDE_SHADER(overlay3D_model_unlit_frag)
INCLUDE_SHADER(overlay3D_model_translucent_unlit_frag)
#include "overlay3D_vert.h"
#include "overlay3D_frag.h"
#include "overlay3D_model_frag.h"
#include "overlay3D_model_translucent_frag.h"
#include "overlay3D_translucent_frag.h"
#include "overlay3D_unlit_frag.h"
#include "overlay3D_translucent_unlit_frag.h"
#include "overlay3D_model_unlit_frag.h"
#include "overlay3D_model_translucent_unlit_frag.h"
INCLUDE_SHADER(model_shadow_vert)
INCLUDE_SHADER(skin_model_shadow_vert)
#include "model_shadow_vert.h"
#include "skin_model_shadow_vert.h"
INCLUDE_SHADER(model_shadow_frag)
INCLUDE_SHADER(skin_model_shadow_frag)
#include "model_shadow_frag.h"
#include "skin_model_shadow_frag.h"
INCLUDE_SHADER(model_shadow_fade_vert)
INCLUDE_SHADER(skin_model_shadow_fade_vert)
#include "model_shadow_fade_vert.h"
#include "skin_model_shadow_fade_vert.h"
INCLUDE_SHADER(model_shadow_fade_frag)
INCLUDE_SHADER(skin_model_shadow_fade_frag)
#include "model_shadow_fade_frag.h"
#include "skin_model_shadow_fade_frag.h"
using namespace render;
using namespace std::placeholders;

4
libraries/render-utils/src/StencilMaskPass.cpp
View file

@ -17,7 +17,7 @@
#include <gpu/StandardShaderLib.h>
INCLUDE_SHADER(stencil_drawMask_frag)
#include "stencil_drawMask_frag.h"
using namespace render;
@ -60,7 +60,7 @@ gpu::PipelinePointer PrepareStencil::getMeshStencilPipeline() {
gpu::PipelinePointer PrepareStencil::getPaintStencilPipeline() {
if (!_paintStencilPipeline) {
auto vs = gpu::StandardShaderLib::getDrawUnitQuadTexcoordVS();
auto ps = gpu::Shader::createPixel(std::string(stencil_drawMask_frag));
auto ps = gpu::Shader::createPixel(std::string(stencil_drawMask_frag);
auto program = gpu::Shader::createProgram(vs, ps);
gpu::Shader::makeProgram((*program));

8
libraries/render-utils/src/SubsurfaceScattering.cpp
View file

@ -17,11 +17,11 @@
#include "DeferredLightingEffect.h"
INCLUDE_SHADER(subsurfaceScattering_makeProfile_frag)
INCLUDE_SHADER(subsurfaceScattering_makeLUT_frag)
INCLUDE_SHADER(subsurfaceScattering_makeSpecularBeckmann_frag)
#include "subsurfaceScattering_makeProfile_frag.h"
#include "subsurfaceScattering_makeLUT_frag.h"
#include "subsurfaceScattering_makeSpecularBeckmann_frag.h"
INCLUDE_SHADER(subsurfaceScattering_drawScattering_frag)
#include "subsurfaceScattering_drawScattering_frag.h"
enum ScatteringShaderBufferSlots {
ScatteringTask_FrameTransformSlot = 0,

12
libraries/render-utils/src/SurfaceGeometryPass.cpp
View file

@ -25,10 +25,10 @@ const int SurfaceGeometryPass_ParamsSlot = 1;
const int SurfaceGeometryPass_DepthMapSlot = 0;
const int SurfaceGeometryPass_NormalMapSlot = 1;
INCLUDE_SHADER(surfaceGeometry_makeLinearDepth_frag)
INCLUDE_SHADER(surfaceGeometry_downsampleDepthNormal_frag)
#include "surfaceGeometry_makeLinearDepth_frag.h"
#include "surfaceGeometry_downsampleDepthNormal_frag.h"
INCLUDE_SHADER(surfaceGeometry_makeCurvature_frag)
#include "surfaceGeometry_makeCurvature_frag.h"
@ -212,7 +212,7 @@ void LinearDepthPass::run(const render::RenderContextPointer& renderContext, con
const gpu::PipelinePointer& LinearDepthPass::getLinearDepthPipeline() {
if (!_linearDepthPipeline) {
auto vs = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_makeLinearDepth_frag));
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_makeLinearDepth_frag);
gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
gpu::Shader::BindingSet slotBindings;
@ -239,7 +239,7 @@ const gpu::PipelinePointer& LinearDepthPass::getLinearDepthPipeline() {
const gpu::PipelinePointer& LinearDepthPass::getDownsamplePipeline() {
if (!_downsamplePipeline) {
auto vs = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_downsampleDepthNormal_frag));
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_downsampleDepthNormal_frag);
gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
gpu::Shader::BindingSet slotBindings;
@ -540,7 +540,7 @@ void SurfaceGeometryPass::run(const render::RenderContextPointer& renderContext,
const gpu::PipelinePointer& SurfaceGeometryPass::getCurvaturePipeline() {
if (!_curvaturePipeline) {
auto vs = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_makeCurvature_frag));
auto ps = gpu::Shader::createPixel(std::string(surfaceGeometry_makeCurvature_frag);
gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
gpu::Shader::BindingSet slotBindings;

4
libraries/render-utils/src/TextRenderer3D.cpp
View file

@ -25,8 +25,8 @@
#include "MatrixStack.h"
#include "RenderUtilsLogging.h"
INCLUDE_SHADER(sdf_text3D_vert)
INCLUDE_SHADER(sdf_text3D_frag)
#include "sdf_text3D_vert.h"
#include "sdf_text3D_frag.h"
#include "GeometryCache.h"

4
libraries/render-utils/src/ToneMappingEffect.cpp
View file

@ -17,7 +17,7 @@
#include "StencilMaskPass.h"
#include "FramebufferCache.h"
INCLUDE_SHADER(toneMapping_frag)
#include "toneMapping_frag.h"
const int ToneMappingEffect_ParamsSlot = 0;
const int ToneMappingEffect_LightingMapSlot = 0;
@ -28,7 +28,7 @@ ToneMappingEffect::ToneMappingEffect() {
}
void ToneMappingEffect::init() {
auto blitPS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(toneMapping_frag)));
auto blitPS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(toneMapping_frag));
auto blitVS = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
auto blitProgram = gpu::ShaderPointer(gpu::Shader::createProgram(blitVS, blitPS));

6
libraries/render-utils/src/ZoneRenderer.cpp
View file

@ -20,9 +20,9 @@
#include "StencilMaskPass.h"
#include "DeferredLightingEffect.h"
INCLUDE_SHADER(zone_drawKeyLight_frag)
INCLUDE_SHADER(zone_drawAmbient_frag)
INCLUDE_SHADER(zone_drawSkybox_frag)
#include "zone_drawKeyLight_frag.h"
#include "zone_drawAmbient_frag.h"
#include "zone_drawSkybox_frag.h"
using namespace render;

6
libraries/render-utils/src/text/Font.cpp
View file

@ -7,9 +7,9 @@
#include <StreamHelpers.h>
INCLUDE_SHADER(sdf_text3D_vert)
INCLUDE_SHADER(sdf_text3D_frag)
INCLUDE_SHADER(sdf_text3D_transparent_frag)
#include "sdf_text3D_vert.h"
#include "sdf_text3D_frag.h"
#include "sdf_text3D_transparent_frag.h"
#include "../RenderUtilsLogging.h"
#include "FontFamilies.h"

8
libraries/render/src/render/BlurTask.cpp
View file

@ -13,11 +13,11 @@
#include <gpu/Context.h>
#include <gpu/StandardShaderLib.h>
INCLUDE_SHADER(blurGaussianV_frag)
INCLUDE_SHADER(blurGaussianH_frag)
#include "blurGaussianV_frag.h"
#include "blurGaussianH_frag.h"
INCLUDE_SHADER(blurGaussianDepthAwareV_frag)
INCLUDE_SHADER(blurGaussianDepthAwareH_frag)
#include "blurGaussianDepthAwareV_frag.h"
#include "blurGaussianDepthAwareH_frag.h"
using namespace render;

10
libraries/render/src/render/DrawSceneOctree.cpp
View file

@ -22,12 +22,12 @@
#include "Args.h"
INCLUDE_SHADER(drawCellBounds_vert)
INCLUDE_SHADER(drawCellBounds_frag)
INCLUDE_SHADER(drawLODReticle_frag)
#include "drawCellBounds_vert.h"
#include "drawCellBounds_frag.h"
#include "drawLODReticle_frag.h"
INCLUDE_SHADER(drawItemBounds_vert)
INCLUDE_SHADER(drawItemBounds_frag)
#include "drawItemBounds_vert.h"
#include "drawItemBounds_frag.h"
using namespace render;

8
libraries/render/src/render/DrawStatus.cpp
View file

@ -21,10 +21,10 @@
#include "Args.h"
INCLUDE_SHADER(drawItemBounds_vert)
INCLUDE_SHADER(drawItemBounds_frag)
INCLUDE_SHADER(drawItemStatus_vert)
INCLUDE_SHADER(drawItemStatus_frag)
#include "drawItemBounds_vert.h"
#include "drawItemBounds_frag.h"
#include "drawItemStatus_vert.h"
#include "drawItemStatus_frag.h"
using namespace render;

4
libraries/render/src/render/DrawTask.cpp
View file

@ -22,8 +22,8 @@
#include <gpu/Context.h>
#include <gpu/StandardShaderLib.h>
INCLUDE_SHADER(drawItemBounds_vert)
INCLUDE_SHADER(drawItemBounds_frag)
#include "drawItemBounds_vert.h"
#include "drawItemBounds_frag.h"
using namespace render;

172
tests/shaders/src/main.cpp
View file

@ -23,65 +23,65 @@
#include <gl/QOpenGLContextWrapper.h>
INCLUDE_SHADER(simple_vert)
INCLUDE_SHADER(simple_frag)
INCLUDE_SHADER(simple_textured_frag)
INCLUDE_SHADER(simple_textured_unlit_frag)
#include "simple_vert.h"
#include "simple_frag.h"
#include "simple_textured_frag.h"
#include "simple_textured_unlit_frag.h"
INCLUDE_SHADER(deferred_light_vert)
INCLUDE_SHADER(deferred_light_point_vert)
INCLUDE_SHADER(deferred_light_spot_vert)
#include "deferred_light_vert.h"
#include "deferred_light_point_vert.h"
#include "deferred_light_spot_vert.h"
INCLUDE_SHADER(directional_ambient_light_frag)
INCLUDE_SHADER(directional_skybox_light_frag)
#include "directional_ambient_light_frag.h"
#include "directional_skybox_light_frag.h"
INCLUDE_SHADER(standardTransformPNTC_vert)
INCLUDE_SHADER(standardDrawTexture_frag)
#include "standardTransformPNTC_vert.h"
#include "standardDrawTexture_frag.h"
INCLUDE_SHADER(model_vert)
INCLUDE_SHADER(model_shadow_vert)
INCLUDE_SHADER(model_normal_map_vert)
INCLUDE_SHADER(model_lightmap_vert)
INCLUDE_SHADER(model_lightmap_normal_map_vert)
INCLUDE_SHADER(skin_model_vert)
INCLUDE_SHADER(skin_model_shadow_vert)
INCLUDE_SHADER(skin_model_normal_map_vert)
#include "model_vert.h"
#include "model_shadow_vert.h"
#include "model_normal_map_vert.h"
#include "model_lightmap_vert.h"
#include "model_lightmap_normal_map_vert.h"
#include "skin_model_vert.h"
#include "skin_model_shadow_vert.h"
#include "skin_model_normal_map_vert.h"
INCLUDE_SHADER(model_frag)
INCLUDE_SHADER(model_shadow_frag)
INCLUDE_SHADER(model_normal_map_frag)
INCLUDE_SHADER(model_normal_specular_map_frag)
INCLUDE_SHADER(model_specular_map_frag)
INCLUDE_SHADER(model_lightmap_frag)
INCLUDE_SHADER(model_lightmap_normal_map_frag)
INCLUDE_SHADER(model_lightmap_normal_specular_map_frag)
INCLUDE_SHADER(model_lightmap_specular_map_frag)
INCLUDE_SHADER(model_translucent_frag)
#include "model_frag.h"
#include "model_shadow_frag.h"
#include "model_normal_map_frag.h"
#include "model_normal_specular_map_frag.h"
#include "model_specular_map_frag.h"
#include "model_lightmap_frag.h"
#include "model_lightmap_normal_map_frag.h"
#include "model_lightmap_normal_specular_map_frag.h"
#include "model_lightmap_specular_map_frag.h"
#include "model_translucent_frag.h"
INCLUDE_SHADER(textured_particle_frag)
INCLUDE_SHADER(textured_particle_vert)
#include "textured_particle_frag.h"
#include "textured_particle_vert.h"
INCLUDE_SHADER(overlay3D_vert)
INCLUDE_SHADER(overlay3D_frag)
#include "overlay3D_vert.h"
#include "overlay3D_frag.h"
INCLUDE_SHADER(skybox_vert)
INCLUDE_SHADER(skybox_frag)
#include "skybox_vert.h"
#include "skybox_frag.h"
INCLUDE_SHADER(DrawTransformUnitQuad_vert)
INCLUDE_SHADER(DrawTexcoordRectTransformUnitQuad_vert)
INCLUDE_SHADER(DrawViewportQuadTransformTexcoord_vert)
INCLUDE_SHADER(DrawTexture_frag)
INCLUDE_SHADER(DrawTextureOpaque_frag)
INCLUDE_SHADER(DrawColoredTexture_frag)
#include "DrawTransformUnitQuad_vert.h"
#include "DrawTexcoordRectTransformUnitQuad_vert.h"
#include "DrawViewportQuadTransformTexcoord_vert.h"
#include "DrawTexture_frag.h"
#include "DrawTextureOpaque_frag.h"
#include "DrawColoredTexture_frag.h"
INCLUDE_SHADER(sdf_text3D_vert)
INCLUDE_SHADER(sdf_text3D_frag)
#include "sdf_text3D_vert.h"
#include "sdf_text3D_frag.h"
INCLUDE_SHADER(paintStroke_vert)
INCLUDE_SHADER(paintStroke_frag)
#include "paintStroke_vert.h"
#include "paintStroke_frag.h"
INCLUDE_SHADER(polyvox_vert)
INCLUDE_SHADER(polyvox_frag)
#include "polyvox_vert.h"
#include "polyvox_frag.h"
// Create a simple OpenGL window that renders text in various ways
class QTestWindow : public QWindow {
@ -159,54 +159,54 @@ void QTestWindow::draw() {
static std::once_flag once;
std::call_once(once, [&]{
testShaderBuild(sdf_text3D_vert, sdf_text3D_frag);
testShaderBuild(sdf_text3D_vert, sdf_text3D_frag.h";
testShaderBuild(DrawTransformUnitQuad_vert, DrawTexture_frag);
testShaderBuild(DrawTexcoordRectTransformUnitQuad_vert, DrawTexture_frag);
testShaderBuild(DrawViewportQuadTransformTexcoord_vert, DrawTexture_frag);
testShaderBuild(DrawTransformUnitQuad_vert, DrawTextureOpaque_frag);
testShaderBuild(DrawTransformUnitQuad_vert, DrawColoredTexture_frag);
testShaderBuild(DrawTransformUnitQuad_vert, DrawTexture_frag.h";
testShaderBuild(DrawTexcoordRectTransformUnitQuad_vert, DrawTexture_frag.h";
testShaderBuild(DrawViewportQuadTransformTexcoord_vert, DrawTexture_frag.h";
testShaderBuild(DrawTransformUnitQuad_vert, DrawTextureOpaque_frag.h";
testShaderBuild(DrawTransformUnitQuad_vert, DrawColoredTexture_frag.h";
testShaderBuild(skybox_vert, skybox_frag);
testShaderBuild(simple_vert, simple_frag);
testShaderBuild(simple_vert, simple_textured_frag);
testShaderBuild(simple_vert, simple_textured_unlit_frag);
testShaderBuild(deferred_light_vert, directional_ambient_light_frag);
testShaderBuild(deferred_light_vert, directional_skybox_light_frag);
testShaderBuild(standardTransformPNTC_vert, standardDrawTexture_frag);
testShaderBuild(standardTransformPNTC_vert, DrawTextureOpaque_frag);
testShaderBuild(skybox_vert, skybox_frag.h";
testShaderBuild(simple_vert, simple_frag.h";
testShaderBuild(simple_vert, simple_textured_frag.h";
testShaderBuild(simple_vert, simple_textured_unlit_frag.h";
testShaderBuild(deferred_light_vert, directional_ambient_light_frag.h";
testShaderBuild(deferred_light_vert, directional_skybox_light_frag.h";
testShaderBuild(standardTransformPNTC_vert, standardDrawTexture_frag.h";
testShaderBuild(standardTransformPNTC_vert, DrawTextureOpaque_frag.h";
testShaderBuild(model_vert, model_frag);
testShaderBuild(model_normal_map_vert, model_normal_map_frag);
testShaderBuild(model_vert, model_specular_map_frag);
testShaderBuild(model_normal_map_vert, model_normal_specular_map_frag);
testShaderBuild(model_vert, model_translucent_frag);
testShaderBuild(model_normal_map_vert, model_translucent_frag);
testShaderBuild(model_lightmap_vert, model_lightmap_frag);
testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_map_frag);
testShaderBuild(model_lightmap_vert, model_lightmap_specular_map_frag);
testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_specular_map_frag);
testShaderBuild(model_vert, model_frag.h";
testShaderBuild(model_normal_map_vert, model_normal_map_frag.h";
testShaderBuild(model_vert, model_specular_map_frag.h";
testShaderBuild(model_normal_map_vert, model_normal_specular_map_frag.h";
testShaderBuild(model_vert, model_translucent_frag.h";
testShaderBuild(model_normal_map_vert, model_translucent_frag.h";
testShaderBuild(model_lightmap_vert, model_lightmap_frag.h";
testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_map_frag.h";
testShaderBuild(model_lightmap_vert, model_lightmap_specular_map_frag.h";
testShaderBuild(model_lightmap_normal_map_vert, model_lightmap_normal_specular_map_frag.h";
testShaderBuild(skin_model_vert, model_frag);
testShaderBuild(skin_model_normal_map_vert, model_normal_map_frag);
testShaderBuild(skin_model_vert, model_specular_map_frag);
testShaderBuild(skin_model_normal_map_vert, model_normal_specular_map_frag);
testShaderBuild(skin_model_vert, model_translucent_frag);
testShaderBuild(skin_model_normal_map_vert, model_translucent_frag);
testShaderBuild(skin_model_vert, model_frag.h";
testShaderBuild(skin_model_normal_map_vert, model_normal_map_frag.h";
testShaderBuild(skin_model_vert, model_specular_map_frag.h";
testShaderBuild(skin_model_normal_map_vert, model_normal_specular_map_frag.h";
testShaderBuild(skin_model_vert, model_translucent_frag.h";
testShaderBuild(skin_model_normal_map_vert, model_translucent_frag.h";
testShaderBuild(model_shadow_vert, model_shadow_frag);
testShaderBuild(textured_particle_vert, textured_particle_frag);
testShaderBuild(model_shadow_vert, model_shadow_frag.h";
testShaderBuild(textured_particle_vert, textured_particle_frag.h";
/* FIXME: Bring back the ssao shader tests
testShaderBuild(gaussian_blur_vertical_vert, gaussian_blur_frag);
testShaderBuild(gaussian_blur_horizontal_vert, gaussian_blur_frag);
testShaderBuild(ambient_occlusion_vert, ambient_occlusion_frag);
testShaderBuild(ambient_occlusion_vert, occlusion_blend_frag);
testShaderBuild(gaussian_blur_vertical_vert, gaussian_blur_frag.h";
testShaderBuild(gaussian_blur_horizontal_vert, gaussian_blur_frag.h";
testShaderBuild(ambient_occlusion_vert, ambient_occlusion_frag.h";
testShaderBuild(ambient_occlusion_vert, occlusion_blend_frag.h";
*/
testShaderBuild(overlay3D_vert, overlay3D_frag);
testShaderBuild(overlay3D_vert, overlay3D_frag.h";
testShaderBuild(paintStroke_vert,paintStroke_frag);
testShaderBuild(polyvox_vert, polyvox_frag);
testShaderBuild(paintStroke_vert,paintStroke_frag.h";
testShaderBuild(polyvox_vert, polyvox_frag.h";
});
_context.swapBuffers(this);

136
tools/scribe/src/main.cpp
View file

@ -44,6 +44,18 @@ int main (int argc, char** argv) {
EXIT,
} mode = READY;
enum Type {
VERTEX = 0,
FRAGMENT,
GEOMETRY,
} type = VERTEX;
static const char* shaderTypeString[] = {
"VERTEX", "PIXEL", "GEOMETRY"
};
static const char* shaderCreateString[] = {
"Vertex", "Pixel", "Geometry"
};
for (int ii = 1; (mode != EXIT) && (ii < argc); ii++) {
inputs.push_back(argv[ii]);
@ -66,6 +78,15 @@ int main (int argc, char** argv) {
} else if (inputs.back() == "-c++") {
makeCPlusPlus = true;
mode = READY;
} else if (inputs.back() == "-vert") {
type = VERTEX;
mode = READY;
} else if (inputs.back() == "-frag") {
type = FRAGMENT;
mode = READY;
} else if (inputs.back() == "-geom") {
type = GEOMETRY;
mode = READY;
} else {
// just grabbed the source filename, stop parameter parsing
srcFilename = inputs.back();
@ -186,7 +207,6 @@ int main (int argc, char** argv) {
scribe->displayTree(cerr, level);
}
std::ostringstream targetStringStream;
if (makeCPlusPlus) {
// Because there is a maximum size for literal strings declared in source we need to partition the
// full source string stream into pages that seems to be around that value...
@ -208,32 +228,108 @@ int main (int argc, char** argv) {
pageSize += lineSize;
}
targetStringStream << "// File generated by Scribe " << vars["_SCRIBE_DATE"] << std::endl;
targetStringStream << "extern const char " << targetName << "[] = \n";
std::stringstream headerStringStream;
std::stringstream sourceStringStream;
std::string headerFileName = destFilename + ".h";
std::string sourceFileName = destFilename + ".cpp";
sourceStringStream << "// File generated by Scribe " << vars["_SCRIBE_DATE"] << std::endl;
// Write header file
headerStringStream << "#ifndef " << targetName << "_h" << std::endl;
headerStringStream << "#define " << targetName << "_h\n" << std::endl;
headerStringStream << "#include <gpu/Shader.h>\n" << std::endl;
headerStringStream << "class " << targetName << " {" << std::endl;
headerStringStream << "public:" << std::endl;
headerStringStream << "\tstatic gpu::Shader::Type getType() { return gpu::Shader::" << shaderTypeString[type] << "; }" << std::endl;
headerStringStream << "\tstatic const char* getSource() { return _source; }" << std::endl;
headerStringStream << "\tstatic gpu::ShaderPointer getShader();" << std::endl;
headerStringStream << "private:" << std::endl;
headerStringStream << "\tstatic const char* _source;" << std::endl;
headerStringStream << "\tstatic gpu::ShaderPointer _shader;" << std::endl;
headerStringStream << "};\n" << std::endl;
headerStringStream << "#endif // " << targetName << "_h" << std::endl;
bool mustOutputHeader = destFilename.empty();
// Compare with existing file
{
std::fstream headerFile;
headerFile.open(headerFileName, std::fstream::in);
if (headerFile.is_open()) {
// Skip first line
std::string line;
std::stringstream previousHeaderStringStream;
std::getline(headerFile, line);
previousHeaderStringStream << headerFile.rdbuf();
mustOutputHeader = mustOutputHeader || previousHeaderStringStream.str() != headerStringStream.str();
} else {
mustOutputHeader = true;
}
}
if (mustOutputHeader) {
if (!destFilename.empty()) {
// File content has changed so write it
std::fstream headerFile;
headerFile.open(headerFileName, std::fstream::out);
if (headerFile.is_open()) {
// First line contains the date of modification
headerFile << sourceStringStream.str();
headerFile << headerStringStream.str();
} else {
cerr << "Scribe output file <" << headerFileName << "> failed to open." << endl;
return 0;
}
} else {
cerr << sourceStringStream.str();
cerr << headerStringStream.str();
}
}
// Write source file
sourceStringStream << "#include \"" << targetName << ".h\"\n" << std::endl;
sourceStringStream << "gpu::ShaderPointer " << targetName << "::_shader;" << std::endl;
sourceStringStream << "const char* " << targetName << "::_source = ";
// Write the pages content
for (auto page : pages) {
targetStringStream << "R\"SCRIBE(\n" << page->str() << "\n)SCRIBE\"\n";
sourceStringStream << "R\"SCRIBE(\n" << page->str() << "\n)SCRIBE\"\n";
}
targetStringStream << ";\n" << std::endl << std::endl;
targetStringStream << "// Hack to fix Android link error by forcing a reference to global variable\n";
targetStringStream << "class " << targetName << "_used {\npublic:\nstatic const char* get() { return " << targetName << "; }\n};\n" << std::endl;
} else {
targetStringStream << destStringStream.str();
}
sourceStringStream << ";\n" << std::endl << std::endl;
// Destination stream
if (!destFilename.empty()) {
std::fstream destFileStream;
destFileStream.open(destFilename, std::fstream::out);
if (!destFileStream.is_open()) {
cerr << "Scribe output file " << destFilename << "> failed to open." << endl;
return 0;
sourceStringStream << "gpu::ShaderPointer " << targetName << "::getShader() {" << std::endl;
sourceStringStream << "\tif (_shader==nullptr) {" << std::endl;
sourceStringStream << "\t\t_shader = gpu::Shader::create" << shaderCreateString[type] << "(std::string(_source));" << std::endl;
sourceStringStream << "\t}" << std::endl;
sourceStringStream << "\treturn _shader;" << std::endl;
sourceStringStream << "}\n" << std::endl;
// Destination stream
if (!destFilename.empty()) {
std::fstream sourceFile;
sourceFile.open(sourceFileName, std::fstream::out);
if (!sourceFile.is_open()) {
cerr << "Scribe output file <" << sourceFileName << "> failed to open." << endl;
return 0;
}
sourceFile << sourceStringStream.str();
} else {
cerr << sourceStringStream.str();
}
destFileStream << targetStringStream.str();
} else {
cerr << targetStringStream.str();
// Destination stream
if (!destFilename.empty()) {
std::fstream destFileStream;
destFileStream.open(destFilename, std::fstream::out);
if (!destFileStream.is_open()) {
cerr << "Scribe output file <" << destFilename << "> failed to open." << endl;
return 0;
}
destFileStream << destStringStream.str();
} else {
cerr << destStringStream.str();
}
}
return 0;