first commit
This commit is contained in:
859
include/engine/core/shader_block.h
Normal file
859
include/engine/core/shader_block.h
Normal file
@ -0,0 +1,859 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
GSFramework
|
||||
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
||||
----------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
#ifndef __NSHADER_BLOCK__
|
||||
#define __NSHADER_BLOCK__
|
||||
|
||||
|
||||
#include "core/shader.h"
|
||||
#include "color/color.h"
|
||||
#include "math/matrix3.h"
|
||||
#include "math/matrix4.h"
|
||||
#include "nstring/nstring.h"
|
||||
|
||||
|
||||
namespace GS {
|
||||
namespace NML { class Tag; }
|
||||
|
||||
namespace Core {
|
||||
struct ShaderBlockPin;
|
||||
struct ShaderBlock;
|
||||
|
||||
typedef ShaderBlock * pShaderBlock;
|
||||
|
||||
/*!
|
||||
@short Block shader value.
|
||||
Used by the raytracer software implementation of the shader blocks.
|
||||
*/
|
||||
struct ShaderBlockValue
|
||||
{
|
||||
enum BlockValueType
|
||||
{
|
||||
BlockValueNone = 0,
|
||||
BlockValueVector,
|
||||
BlockValueMatrix3,
|
||||
BlockValueMatrix4,
|
||||
BlockValueTexture
|
||||
};
|
||||
|
||||
BlockValueType type;
|
||||
|
||||
// Can't union those and most of all we don't want runtime allocations here...
|
||||
Vector4 v;
|
||||
Matrix3 m3;
|
||||
Matrix4 m4;
|
||||
String t;
|
||||
|
||||
void Set(const float &_f)
|
||||
{ v.x = _f; type = BlockValueVector; }
|
||||
void Set(const Vector4 &_v)
|
||||
{ v = _v; type = BlockValueVector; }
|
||||
void Set(const Matrix3 &_m)
|
||||
{ m3 = _m; type = BlockValueMatrix3; }
|
||||
void Set(const Matrix4 &_m)
|
||||
{ m4 = _m; type = BlockValueMatrix4; }
|
||||
|
||||
void Set(const char *_t)
|
||||
{ t = _t; type = BlockValueTexture; }
|
||||
|
||||
ShaderBlockValue() : type(BlockValueNone) {}
|
||||
};
|
||||
|
||||
/*!
|
||||
@short Base render block.
|
||||
|
||||
A render block is a component of a render map. It represents an input, an
|
||||
operator to the render map.
|
||||
|
||||
@author Emmanuel Julien (ejulien@gsworks.fr)
|
||||
*/
|
||||
struct ShaderBlock
|
||||
{
|
||||
enum BlockType
|
||||
{
|
||||
TypeNone = 0,
|
||||
|
||||
// Input blocks.
|
||||
TypeGeometryVertex,
|
||||
TypeGeometryNormal,
|
||||
TypeGeometryUV,
|
||||
TypeGeometrySkinning,
|
||||
TypeGeometryVertexColor,
|
||||
TypeGeometryTangentFrame,
|
||||
TypeRenderBuffer,
|
||||
TypeTexture,
|
||||
TypeTextureSampler,
|
||||
TypeConstant,
|
||||
TypeColor,
|
||||
TypeMaterialParam,
|
||||
TypeMaterialTexture,
|
||||
TypeScreenUV,
|
||||
TypeViewVector,
|
||||
TypeViewport,
|
||||
|
||||
// Matrix blocks.
|
||||
TypeNormalViewMatrix,
|
||||
TypeNormalMatrix,
|
||||
TypeModelViewMatrix,
|
||||
TypeModelMatrix,
|
||||
|
||||
// Operator blocks.
|
||||
TypeMix,
|
||||
TypeAdd,
|
||||
TypeMul,
|
||||
TypeSub,
|
||||
TypeDiv,
|
||||
TypeDot,
|
||||
TypeCross,
|
||||
TypeClamp,
|
||||
TypeNormalize,
|
||||
TypeSwizzle,
|
||||
TypeBuild,
|
||||
TypeSin,
|
||||
TypeCos,
|
||||
TypePow,
|
||||
TypeAbs,
|
||||
|
||||
// Packing operators.
|
||||
TypeUnpackColorToVector,
|
||||
TypePackVectorToColor,
|
||||
|
||||
// Engine parameters.
|
||||
TypeClock,
|
||||
|
||||
TypeInvalid
|
||||
};
|
||||
|
||||
/// Verbose block type.
|
||||
static const char *BlockTypeToString(BlockType type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case TypeNone: return "None";
|
||||
|
||||
case TypeGeometryVertex: return "Geometry Vertex";
|
||||
case TypeGeometryNormal: return "Geometry Normal";
|
||||
case TypeGeometryUV: return "Geometry UV";
|
||||
case TypeGeometrySkinning: return "Geometry Skinning";
|
||||
case TypeGeometryVertexColor: return "Geometry RGB";
|
||||
case TypeGeometryTangentFrame: return "Geometry Tangent Frame";
|
||||
case TypeRenderBuffer: return "Render Buffer";
|
||||
case TypeTexture: return "Texture";
|
||||
case TypeTextureSampler: return "Texture Sampler";
|
||||
case TypeConstant: return "Constant";
|
||||
case TypeColor: return "Color";
|
||||
case TypeMaterialParam: return "Material Parameter";
|
||||
case TypeMaterialTexture: return "Material Texture";
|
||||
case TypeScreenUV: return "Screen UV";
|
||||
case TypeViewVector: return "View Vector";
|
||||
case TypeViewport: return "Viewport";
|
||||
|
||||
case TypeNormalViewMatrix: return "Normal View Matrix";
|
||||
case TypeNormalMatrix: return "Normal Matrix "; ///< ! The additional space is NEEDED! (Normal matrix is the name of a legacy version of this node)
|
||||
case TypeModelViewMatrix: return "Model View Matrix";
|
||||
case TypeModelMatrix: return "Model Matrix";
|
||||
|
||||
case TypeMix: return "Mix";
|
||||
case TypeAdd: return "Add";
|
||||
case TypeMul: return "Multiply";
|
||||
case TypeSub: return "Subtract";
|
||||
case TypeDiv: return "Divide";
|
||||
case TypeDot: return "Dot";
|
||||
case TypeCross: return "Cross";
|
||||
case TypeClamp: return "Clamp";
|
||||
case TypeNormalize: return "Normalize";
|
||||
case TypeSwizzle: return "Swizzle";
|
||||
case TypeBuild: return "Build";
|
||||
case TypeSin: return "Sinus";
|
||||
case TypeCos: return "Cosinus";
|
||||
case TypePow: return "Pow";
|
||||
case TypeAbs: return "Abs";
|
||||
|
||||
case TypeUnpackColorToVector: return "Unpack color to vector";
|
||||
case TypePackVectorToColor: return "Pack vector to color";
|
||||
|
||||
case TypeClock: return "Clock";
|
||||
|
||||
case TypeInvalid: break;
|
||||
}
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
Vector2 pos;
|
||||
BlockType type;
|
||||
|
||||
/*
|
||||
@name Block input/output.
|
||||
@{
|
||||
*/
|
||||
/// Get input count.
|
||||
virtual uint GetInputCount() const = 0;
|
||||
/// Get input block.
|
||||
virtual ShaderBlock *GetInput(uint n) const = 0;
|
||||
/// Set input.
|
||||
virtual bool SetInput(uint n, ShaderBlock *in) = 0;
|
||||
|
||||
/// Get input pin.
|
||||
virtual const ShaderBlockPin *GetInputPin(uint n) const = 0;
|
||||
/// Get block output pin.
|
||||
virtual const ShaderBlockPin *GetOutputPin() const = 0;
|
||||
|
||||
/// Evaluate block output type.
|
||||
virtual int GetOutputType() const = 0;
|
||||
/// @}
|
||||
|
||||
/// Get block label.
|
||||
virtual String GetLabel() const = 0;
|
||||
/// Get block id.
|
||||
virtual String GetId() const = 0;
|
||||
|
||||
/// Is this block equivalent to another block.
|
||||
bool IsEquivalent(const ShaderBlock *input_block) const;
|
||||
|
||||
/// Gather all of this block children.
|
||||
void GatherChildren(List <ShaderBlock *> &children);
|
||||
|
||||
/// Import block map from metatag.
|
||||
static Array <pShaderBlock> *BlockMapFromMetaTag(NML::Tag &);
|
||||
/// Import branch from metatag.
|
||||
static ShaderBlock *BranchFromMetaTag(NML::Tag &, Array <pShaderBlock> *block_map = 0);
|
||||
|
||||
static NML::Tag *BlockMapAsMetaTag(const List <ShaderBlock *> &block_map);
|
||||
NML::Tag *BranchAsMetaTag(List <ShaderBlock *> &block_map);
|
||||
NML::Tag *ParamAsMetaTag() const;
|
||||
|
||||
ShaderBlock() : type(TypeNone) {}
|
||||
virtual ~ShaderBlock() {}
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
#define __SpecializeBlock(__LABEL__, __INPUT_COUNT__)\
|
||||
static ShaderBlockPin input_pin[__INPUT_COUNT__];\
|
||||
static ShaderBlockPin output_pin;\
|
||||
\
|
||||
ShaderBlock *input[__INPUT_COUNT__];\
|
||||
\
|
||||
String GetLabel() const\
|
||||
{ return __LABEL__; }\
|
||||
uint GetInputCount() const\
|
||||
{ return __INPUT_COUNT__; }\
|
||||
bool SetInput(uint n, ShaderBlock *block)\
|
||||
{\
|
||||
if (n >= __INPUT_COUNT__)\
|
||||
return false;\
|
||||
if (block && !(input_pin[n].compatibility & block->GetOutputType()))\
|
||||
return false;\
|
||||
input[n] = block;\
|
||||
return true;\
|
||||
}\
|
||||
ShaderBlock *GetInput(uint n) const\
|
||||
{ return (n < __INPUT_COUNT__) ? input[n] : 0; }\
|
||||
const ShaderBlockPin *GetInputPin(uint n) const\
|
||||
{ return (n < __INPUT_COUNT__) ? &input_pin[n] : 0; }\
|
||||
const ShaderBlockPin *GetOutputPin() const\
|
||||
{ return &output_pin; }\
|
||||
int GetOutputType() const;
|
||||
|
||||
#define __SpecializeBlockNoInput(__LABEL__)\
|
||||
static ShaderBlockPin output_pin;\
|
||||
\
|
||||
String GetLabel() const\
|
||||
{ return __LABEL__; }\
|
||||
uint GetInputCount() const\
|
||||
{ return 0; }\
|
||||
bool SetInput(uint /*n*/, ShaderBlock */*block*/)\
|
||||
{ return false; }\
|
||||
ShaderBlock *GetInput(uint /*n*/) const\
|
||||
{ return 0; }\
|
||||
const ShaderBlockPin *GetInputPin(uint /*n*/) const\
|
||||
{ return 0; }\
|
||||
const ShaderBlockPin *GetOutputPin() const\
|
||||
{ return &output_pin; }\
|
||||
int GetOutputType() const;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
@short Render block pin description.
|
||||
@author Emmanuel Julien (ejulien@gsworks.fr)
|
||||
*/
|
||||
struct ShaderBlockPin
|
||||
{
|
||||
const char *name,
|
||||
*desc;
|
||||
int compatibility; ///< Pin connection compatibility
|
||||
};
|
||||
|
||||
struct SinusShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Sinus", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "Sin"; }
|
||||
SinusShaderBlock(ShaderBlock *block = 0)
|
||||
{
|
||||
type = TypeSin;
|
||||
input[0] = block;
|
||||
}
|
||||
};
|
||||
|
||||
struct CosinusShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Cosinus", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "Cos"; }
|
||||
CosinusShaderBlock(ShaderBlock *block = 0)
|
||||
{
|
||||
type = TypeCos;
|
||||
input[0] = block;
|
||||
}
|
||||
};
|
||||
|
||||
struct PowShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Pow", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Pow"; }
|
||||
PowShaderBlock(ShaderBlock *v = 0, ShaderBlock *p = 0)
|
||||
{
|
||||
type = TypePow;
|
||||
input[0] = v;
|
||||
input[1] = p;
|
||||
}
|
||||
};
|
||||
|
||||
struct AbsShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Abs", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "Abs"; }
|
||||
AbsShaderBlock(ShaderBlock *v = 0)
|
||||
{
|
||||
type = TypeAbs;
|
||||
input[0] = v;
|
||||
}
|
||||
};
|
||||
|
||||
struct ClockShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Clock")
|
||||
|
||||
String GetId() const
|
||||
{ return "Clock"; }
|
||||
ClockShaderBlock()
|
||||
{ type = TypeClock; }
|
||||
};
|
||||
|
||||
struct ScreenUVShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Screen UV")
|
||||
|
||||
String GetId() const
|
||||
{ return "ScreenUV"; }
|
||||
ScreenUVShaderBlock()
|
||||
{ type = TypeScreenUV; }
|
||||
};
|
||||
|
||||
struct ViewVectorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("View Vector")
|
||||
|
||||
String GetId() const
|
||||
{ return "ViewV"; }
|
||||
ViewVectorShaderBlock()
|
||||
{ type = TypeViewVector; }
|
||||
};
|
||||
|
||||
struct ViewportShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Viewport")
|
||||
|
||||
String GetId() const
|
||||
{ return "Viewport"; }
|
||||
ViewportShaderBlock()
|
||||
{ type = TypeViewport; }
|
||||
};
|
||||
|
||||
struct NormalViewMatrixShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Normal View Matrix")
|
||||
|
||||
String GetId() const
|
||||
{ return "NormalViewMatrix"; }
|
||||
NormalViewMatrixShaderBlock()
|
||||
{ type = TypeNormalViewMatrix; }
|
||||
};
|
||||
|
||||
struct NormalMatrixShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Normal Matrix ")
|
||||
|
||||
String GetId() const
|
||||
{ return "NormalMatrix"; }
|
||||
NormalMatrixShaderBlock()
|
||||
{ type = TypeNormalMatrix; }
|
||||
};
|
||||
|
||||
struct ModelViewMatrixShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Model View Matrix ")
|
||||
|
||||
String GetId() const
|
||||
{ return "ModelViewMatrix"; }
|
||||
ModelViewMatrixShaderBlock()
|
||||
{ type = TypeModelViewMatrix; }
|
||||
};
|
||||
|
||||
struct ModelMatrixShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Model Matrix")
|
||||
|
||||
String GetId() const
|
||||
{ return "ModelMatrix"; }
|
||||
ModelMatrixShaderBlock()
|
||||
{ type = TypeModelMatrix; }
|
||||
};
|
||||
|
||||
struct UnpackColorToVectorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Unpack Color", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "UnpackColor"; }
|
||||
UnpackColorToVectorShaderBlock(ShaderBlock *block = 0)
|
||||
{
|
||||
type = TypeUnpackColorToVector;
|
||||
input[0] = block;
|
||||
}
|
||||
};
|
||||
|
||||
struct PackVectorToColorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Pack Vector", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "PackVector"; }
|
||||
PackVectorToColorShaderBlock(ShaderBlock *block = 0)
|
||||
{
|
||||
type = TypePackVectorToColor;
|
||||
input[0] = block;
|
||||
}
|
||||
};
|
||||
|
||||
struct MixOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Mix", 3)
|
||||
|
||||
String GetId() const
|
||||
{ return "Mix"; }
|
||||
MixOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0, ShaderBlock *k = 0)
|
||||
{
|
||||
type = TypeMix;
|
||||
input[0] = a; input[1] = b; input[2] = k;
|
||||
}
|
||||
};
|
||||
|
||||
struct AddOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Add", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Add"; }
|
||||
AddOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeAdd;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct MulOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Mul", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Mul"; }
|
||||
MulOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeMul;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct SubOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Sub", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Sub"; }
|
||||
SubOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeSub;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct DivOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Div", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Div"; }
|
||||
DivOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeDiv;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct DotOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Dot", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Dot"; }
|
||||
DotOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeDot;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct CrossOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Cross", 2)
|
||||
|
||||
String GetId() const
|
||||
{ return "Cross"; }
|
||||
CrossOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeCross;
|
||||
input[0] = a; input[1] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct NormalizeOperatorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Normalize", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return "Norm"; }
|
||||
NormalizeOperatorShaderBlock(ShaderBlock *a = 0)
|
||||
{
|
||||
type = TypeNormalize;
|
||||
input[0] = a;
|
||||
}
|
||||
};
|
||||
|
||||
struct ClampShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Clamp", 3)
|
||||
|
||||
String GetId() const
|
||||
{ return "Clamp"; }
|
||||
ClampShaderBlock(ShaderBlock *v = 0, ShaderBlock *a = 0, ShaderBlock *b = 0)
|
||||
{
|
||||
type = TypeClamp;
|
||||
input[0] = v; input[1] = a; input[2] = b;
|
||||
}
|
||||
};
|
||||
|
||||
struct SwizzleShaderBlock : public ShaderBlock
|
||||
{
|
||||
enum Swizzle
|
||||
{
|
||||
SwizzleNone = 0,
|
||||
SwizzleX,
|
||||
SwizzleY,
|
||||
SwizzleZ,
|
||||
SwizzleW
|
||||
};
|
||||
|
||||
__SpecializeBlock("Swizzle", 1)
|
||||
|
||||
String GetId() const
|
||||
{ return String::Format("Swizzle%d%d%d%d", swizzle[0], swizzle[1], swizzle[2], swizzle[3]); }
|
||||
Swizzle swizzle[4];
|
||||
SwizzleShaderBlock(ShaderBlock *block = 0, Swizzle x = SwizzleNone, Swizzle y = SwizzleNone, Swizzle z = SwizzleNone, Swizzle w = SwizzleNone)
|
||||
{
|
||||
type = TypeSwizzle;
|
||||
swizzle[0] = x; swizzle[1] = y; swizzle[2] = z; swizzle[3] = w;
|
||||
input[0] = block;
|
||||
}
|
||||
};
|
||||
|
||||
struct BuildShaderBlock : public ShaderBlock
|
||||
{
|
||||
enum Build
|
||||
{
|
||||
BuildZero = 0,
|
||||
BuildOne,
|
||||
BuildX,
|
||||
BuildY,
|
||||
BuildZ,
|
||||
BuildW
|
||||
};
|
||||
|
||||
__SpecializeBlock("Build", 4)
|
||||
|
||||
Build build[4];
|
||||
String GetId() const
|
||||
{ return String::Format("Build%d%d%d%d", build[0], build[1], build[2], build[3]); }
|
||||
BuildShaderBlock(ShaderBlock *a = 0, Build x = BuildX, ShaderBlock *b = 0, Build y = BuildY, ShaderBlock *c = 0, Build z = BuildZ, ShaderBlock *d = 0, Build w = BuildW)
|
||||
{
|
||||
type = TypeBuild;
|
||||
build[0] = x; build[1] = y; build[2] = z; build[3] = w;
|
||||
input[0] = a; input[1] = b; input[2] = c; input[3] = d;
|
||||
}
|
||||
};
|
||||
|
||||
struct GeometryUVShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("UV Stream")
|
||||
|
||||
int channel;
|
||||
String GetId() const
|
||||
{ return String::Format("UV%d", channel); }
|
||||
|
||||
GeometryUVShaderBlock(int uv_channel = 0)
|
||||
{
|
||||
type = TypeGeometryUV;
|
||||
channel = uv_channel;
|
||||
}
|
||||
};
|
||||
|
||||
struct GeometryVertexShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Vertex Stream")
|
||||
|
||||
String GetId() const
|
||||
{ return String("Vertex"); }
|
||||
|
||||
GeometryVertexShaderBlock()
|
||||
{ type = TypeGeometryVertex; }
|
||||
};
|
||||
|
||||
struct GeometryNormalShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Normal Stream")
|
||||
|
||||
bool smooth;
|
||||
String GetId() const
|
||||
{ return String(smooth ? "NormalSmooth" : "Normal"); }
|
||||
|
||||
GeometryNormalShaderBlock()
|
||||
{
|
||||
type = TypeGeometryNormal;
|
||||
smooth = true;
|
||||
}
|
||||
};
|
||||
|
||||
struct GeometrySkinningShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Skinning Matrix")
|
||||
|
||||
String GetId() const
|
||||
{ return String("SkinMtx"); }
|
||||
|
||||
GeometrySkinningShaderBlock()
|
||||
{ type = TypeGeometrySkinning; }
|
||||
};
|
||||
|
||||
struct GeometryVertexColorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Vertex Color Stream")
|
||||
|
||||
String GetId() const
|
||||
{ return String("VertexColor"); }
|
||||
GeometryVertexColorShaderBlock()
|
||||
{ type = TypeGeometryVertexColor; }
|
||||
};
|
||||
|
||||
struct GeometryTangentFrameShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Tangent Frame")
|
||||
|
||||
String GetId() const
|
||||
{ return String("TangentMtx"); }
|
||||
|
||||
GeometryTangentFrameShaderBlock()
|
||||
{ type = TypeGeometryTangentFrame; }
|
||||
};
|
||||
|
||||
struct RenderBufferShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Render Buffer")
|
||||
|
||||
enum RenderBuffer
|
||||
{
|
||||
Depth = 0
|
||||
};
|
||||
|
||||
RenderBuffer buffer;
|
||||
String GetId() const
|
||||
{ return String("RenderBuffer"); }
|
||||
|
||||
RenderBufferShaderBlock(RenderBuffer _buffer = Depth)
|
||||
{
|
||||
type = TypeRenderBuffer;
|
||||
buffer = _buffer;
|
||||
}
|
||||
};
|
||||
|
||||
struct TextureShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Texture")
|
||||
|
||||
enum TextureType
|
||||
{
|
||||
Texture2D = 0,
|
||||
Texture3D,
|
||||
TextureCube
|
||||
};
|
||||
TextureType texture_type;
|
||||
|
||||
String texture;
|
||||
String GetId() const;
|
||||
|
||||
TextureShaderBlock(const char *name = 0)
|
||||
{
|
||||
type = TypeTexture;
|
||||
texture = name;
|
||||
texture_type = Texture2D;
|
||||
}
|
||||
};
|
||||
|
||||
struct TextureSamplerShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlock("Texture Sampler", 2)
|
||||
|
||||
enum SamplerType
|
||||
{
|
||||
Sampler2D = 0,
|
||||
Sampler3D,
|
||||
SamplerCube
|
||||
};
|
||||
SamplerType sampler_type;
|
||||
|
||||
String GetId() const
|
||||
{ return String::Format("TexSampler%d", (int)sampler_type); }
|
||||
|
||||
TextureSamplerShaderBlock(ShaderBlock *texture = 0, ShaderBlock *uv = 0)
|
||||
{
|
||||
type = TypeTextureSampler;
|
||||
|
||||
sampler_type = Sampler2D;
|
||||
input[0] = texture;
|
||||
input[1] = uv;
|
||||
}
|
||||
};
|
||||
|
||||
struct MaterialParamShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Material Parameter")
|
||||
|
||||
enum MaterialParam
|
||||
{
|
||||
MaterialDiffuse = 0,
|
||||
MaterialSpecular,
|
||||
MaterialSelf,
|
||||
MaterialAmbient,
|
||||
MaterialGlossiness,
|
||||
MaterialOpacity,
|
||||
MaterialReflection
|
||||
};
|
||||
|
||||
MaterialParam param;
|
||||
|
||||
String GetId() const;
|
||||
MaterialParamShaderBlock(MaterialParam p = MaterialDiffuse)
|
||||
{
|
||||
type = TypeMaterialParam;
|
||||
param = p;
|
||||
}
|
||||
};
|
||||
|
||||
struct MaterialTextureShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Material Texture")
|
||||
|
||||
enum TextureType
|
||||
{
|
||||
Texture2D = 0,
|
||||
Texture3D,
|
||||
TextureCube
|
||||
};
|
||||
TextureType texture_type;
|
||||
int slot;
|
||||
|
||||
String GetId() const;
|
||||
|
||||
MaterialTextureShaderBlock(int n = 0)
|
||||
{
|
||||
type = TypeMaterialTexture;
|
||||
texture_type = Texture2D;
|
||||
slot = n;
|
||||
}
|
||||
};
|
||||
|
||||
struct ColorShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Color")
|
||||
|
||||
Color color;
|
||||
|
||||
String GetId() const
|
||||
{ return "Color"; }
|
||||
|
||||
ColorShaderBlock(float r = 1, float g = 1, float b = 1, float a = 1)
|
||||
{
|
||||
type = TypeColor;
|
||||
color.Set(r, g, b, a);
|
||||
}
|
||||
};
|
||||
|
||||
struct ConstantShaderBlock : public ShaderBlock
|
||||
{
|
||||
__SpecializeBlockNoInput("Constant")
|
||||
|
||||
float constant[4];
|
||||
ShaderInput::DataType constant_type;
|
||||
String GetId() const;
|
||||
|
||||
ConstantShaderBlock()
|
||||
{
|
||||
type = TypeConstant; constant_type = ShaderInput::NoData;
|
||||
constant[0] = constant[1] = constant[2] = constant[3] = 0;
|
||||
}
|
||||
ConstantShaderBlock(float v)
|
||||
{
|
||||
type = TypeConstant; constant_type = ShaderInput::Float;
|
||||
constant[0] = v; constant[1] = constant[2] = constant[3] = 0;
|
||||
}
|
||||
ConstantShaderBlock(float u, float v)
|
||||
{
|
||||
type = TypeConstant; constant_type = ShaderInput::Vector2;
|
||||
constant[0] = u; constant[1] = v; constant[2] = constant[3] = 0;
|
||||
}
|
||||
ConstantShaderBlock(float x, float y, float z)
|
||||
{
|
||||
type = TypeConstant; constant_type = ShaderInput::Vector3;
|
||||
constant[0] = x; constant[1] = y; constant[2] = z; constant[3] = 0;
|
||||
}
|
||||
ConstantShaderBlock(float x, float y, float z, float w)
|
||||
{
|
||||
type = TypeConstant; constant_type = ShaderInput::Vector4;
|
||||
constant[0] = x; constant[1] = y; constant[2] = z; constant[3] = w;
|
||||
}
|
||||
};
|
||||
|
||||
} // Core
|
||||
} // GS
|
||||
|
||||
|
||||
#endif // __NSHADER_BLOCK__
|
||||
Reference in New Issue
Block a user