447 lines
19 KiB
C++
447 lines
19 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "core/shader_block.h"
|
|
#include "log/log.h"
|
|
|
|
using namespace GS::Core;
|
|
using GS::String;
|
|
|
|
|
|
// Tools.
|
|
ShaderBlockPin SwizzleShaderBlock::input_pin[] =
|
|
{ { "Input", "Source input to extract components from.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin SwizzleShaderBlock::output_pin =
|
|
{ "Swizzled", "Swizzled input.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin BuildShaderBlock::input_pin[] =
|
|
{ { "Input X", "Source component of the built vector.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input Y", "Source component of the built vector.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input Z", "Source component of the built vector.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input W", "Source component of the built vector.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin BuildShaderBlock::output_pin =
|
|
{ "Built", "Built vector.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin ClampShaderBlock::input_pin[] =
|
|
{ { "Input", "Source to clamp.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Min", "Minimum value.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Max", "Maximum value.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin ClampShaderBlock::output_pin =
|
|
{ "Clamped", "Clamped input.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin UnpackColorToVectorShaderBlock::input_pin[] =
|
|
{ { "Input", "Vector in the [0;1] range.", ShaderInput::Float | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin UnpackColorToVectorShaderBlock::output_pin =
|
|
{ "Unpacked [-1;1]", "Vector in the [-1;1] range.", ShaderInput::NoData };
|
|
ShaderBlockPin PackVectorToColorShaderBlock::input_pin[] =
|
|
{ { "Input", "Vector in the [-1;1] range.", ShaderInput::Float | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin PackVectorToColorShaderBlock::output_pin =
|
|
{ "Packed [0;1]", "Vector in the [0;1] range.", ShaderInput::NoData };
|
|
|
|
// Operator.
|
|
ShaderBlockPin MixOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input K", "Source input K.", ShaderInput::Float } };
|
|
ShaderBlockPin MixOperatorShaderBlock::output_pin =
|
|
{ "A*K+B*(1-K)", "Input A * Input K + Input B * (1.0 - Input K).", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin AddOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin AddOperatorShaderBlock::output_pin =
|
|
{ "A+B", "Input A + Input B.", ShaderInput::NoData };
|
|
ShaderBlockPin SubOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin SubOperatorShaderBlock::output_pin =
|
|
{ "A-B", "Input A - Input B.", ShaderInput::NoData };
|
|
ShaderBlockPin MulOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 | ShaderInput::Matrix3 | ShaderInput::Matrix4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 | ShaderInput::Matrix3 | ShaderInput::Matrix4 } };
|
|
ShaderBlockPin MulOperatorShaderBlock::output_pin =
|
|
{ "A*B", "Input A * Input B.", ShaderInput::NoData };
|
|
ShaderBlockPin DivOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin DivOperatorShaderBlock::output_pin =
|
|
{ "A/B", "Input A / Input B.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin DotOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 },
|
|
{ "Input B", "Source input B.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin DotOperatorShaderBlock::output_pin =
|
|
{ "A.Dot(B)", "The cosinus of the angle between A and B.", ShaderInput::NoData };
|
|
ShaderBlockPin CrossOperatorShaderBlock::input_pin[] =
|
|
{ { "Input A", "Source input A.", ShaderInput::Vector3 },
|
|
{ "Input B", "Source input B.", ShaderInput::Vector3 } };
|
|
ShaderBlockPin CrossOperatorShaderBlock::output_pin =
|
|
{ "A.Cross(B)", "A vector perpendicular to both A and B.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin NormalizeOperatorShaderBlock::input_pin[] =
|
|
{ { "Input", "Source input.", ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin NormalizeOperatorShaderBlock::output_pin =
|
|
{ "Normalized", "Normalized input.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin CosinusShaderBlock::input_pin[] =
|
|
{ { "Input", "Input value in radian.", ShaderInput::Float } };
|
|
ShaderBlockPin CosinusShaderBlock::output_pin =
|
|
{ "Cosinus", "Cosinus of input.", ShaderInput::NoData };
|
|
ShaderBlockPin SinusShaderBlock::input_pin[] =
|
|
{ { "Input", "Input value in radian.", ShaderInput::Float } };
|
|
ShaderBlockPin SinusShaderBlock::output_pin =
|
|
{ "Sinus", "Sinus of input.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin PowShaderBlock::input_pin[] =
|
|
{ { "Value", "Input value.", ShaderInput::Float },
|
|
{ "Power", "Power to raise value to.", ShaderInput::Float } };
|
|
ShaderBlockPin PowShaderBlock::output_pin =
|
|
{ "Pow", "Value raised to power.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin AbsShaderBlock::input_pin[] =
|
|
{ { "Value", "Input value.", ShaderInput::Float | ShaderInput::Vector2 | ShaderInput::Vector3 | ShaderInput::Vector4 } };
|
|
ShaderBlockPin AbsShaderBlock::output_pin =
|
|
{ "Abs", "Absolute value of input.", ShaderInput::NoData };
|
|
|
|
// Texture
|
|
ShaderBlockPin TextureSamplerShaderBlock::input_pin[] =
|
|
{ { "Texture", "Texture input.", ShaderInput::Texture2D },
|
|
{ "UV Stream", "UV stream input.", ShaderInput::Vector2 | ShaderInput::Vector3 } };
|
|
ShaderBlockPin TextureSamplerShaderBlock::output_pin =
|
|
{ "Texel", "Texture sample.", ShaderInput::NoData };
|
|
|
|
// No input blocks.
|
|
ShaderBlockPin GeometryVertexShaderBlock::output_pin =
|
|
{ "Vertex", "Vertex stream.", ShaderInput::NoData };
|
|
ShaderBlockPin GeometrySkinningShaderBlock::output_pin =
|
|
{ "Skinned", "Skinned vector.", ShaderInput::NoData };
|
|
ShaderBlockPin GeometryNormalShaderBlock::output_pin =
|
|
{ "Normal", "Normal stream.", ShaderInput::NoData };
|
|
ShaderBlockPin GeometryUVShaderBlock::output_pin =
|
|
{ "UV", "UV stream.", ShaderInput::NoData };
|
|
ShaderBlockPin GeometryVertexColorShaderBlock::output_pin =
|
|
{ "Color", "Vertex color stream.", ShaderInput::NoData };
|
|
ShaderBlockPin GeometryTangentFrameShaderBlock::output_pin =
|
|
{ "Tangent", "Tangent frame.", ShaderInput::NoData };
|
|
ShaderBlockPin RenderBufferShaderBlock::output_pin =
|
|
{ "Buffer", "Texture object.", ShaderInput::NoData };
|
|
ShaderBlockPin TextureShaderBlock::output_pin =
|
|
{ "Texture", "Texture object.", ShaderInput::NoData };
|
|
ShaderBlockPin ConstantShaderBlock::output_pin =
|
|
{ "Constant", "Constant value.", ShaderInput::NoData };
|
|
ShaderBlockPin ColorShaderBlock::output_pin =
|
|
{ "Color", "RGBA Color.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin MaterialParamShaderBlock::output_pin =
|
|
{ "Parameter", "Material parameter.", ShaderInput::NoData };
|
|
ShaderBlockPin MaterialTextureShaderBlock::output_pin =
|
|
{ "Slot", "Texture slot.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin ClockShaderBlock::output_pin =
|
|
{ "Clock (s)", "System clock in second.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin ScreenUVShaderBlock::output_pin =
|
|
{ "Screen UV", "Screen position.", ShaderInput::NoData };
|
|
ShaderBlockPin ViewVectorShaderBlock::output_pin =
|
|
{ "World View", "View vector in world space.", ShaderInput::NoData };
|
|
ShaderBlockPin ViewportShaderBlock::output_pin =
|
|
{ "Viewport", "Viewport origin and dimension in 2d.", ShaderInput::NoData };
|
|
|
|
ShaderBlockPin NormalViewMatrixShaderBlock::output_pin =
|
|
{ "Normal View Matrix", "Normal view matrix.", ShaderInput::NoData };
|
|
ShaderBlockPin NormalMatrixShaderBlock::output_pin =
|
|
{ "Normal Matrix", "Normal matrix.", ShaderInput::NoData };
|
|
ShaderBlockPin ModelViewMatrixShaderBlock::output_pin =
|
|
{ "Model View Matrix", "Model view matrix.", ShaderInput::NoData };
|
|
ShaderBlockPin ModelMatrixShaderBlock::output_pin =
|
|
{ "Model Matrix", "Model matrix.", ShaderInput::NoData };
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
String TextureShaderBlock::GetId() const
|
|
{ return String("Texture") + texture; }
|
|
|
|
String ConstantShaderBlock::GetId() const
|
|
{
|
|
switch (constant_type)
|
|
{
|
|
case ShaderInput::NoData:
|
|
return String("ConstNone");
|
|
case ShaderInput::Float:
|
|
return String("ConstFloat");
|
|
case ShaderInput::Vector2:
|
|
return String("ConstVec2");
|
|
case ShaderInput::Vector3:
|
|
return String("ConstVec3");
|
|
case ShaderInput::Vector4:
|
|
return String("ConstVec4");
|
|
}
|
|
__ERR__(__LOG_E__ << "Unknown constant.\n", String("ConstUnk"))
|
|
}
|
|
|
|
String MaterialParamShaderBlock::GetId() const
|
|
{ return String::Format("MatParm%d", param); }
|
|
|
|
String MaterialTextureShaderBlock::GetId() const
|
|
{ return String::Format("MatTexture%d", slot); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool ShaderBlock::IsEquivalent(const ShaderBlock *input_block) const
|
|
{
|
|
if (this == input_block)
|
|
return true;
|
|
|
|
if (type == input_block->type)
|
|
switch (type)
|
|
{
|
|
case ShaderBlock::TypeRenderBuffer:
|
|
{
|
|
RenderBufferShaderBlock *a = (RenderBufferShaderBlock *)this, *b = (RenderBufferShaderBlock *)input_block;
|
|
return a->buffer == b->buffer;
|
|
}
|
|
|
|
case ShaderBlock::TypeTextureSampler:
|
|
{
|
|
TextureSamplerShaderBlock *a = (TextureSamplerShaderBlock *)this, *b = (TextureSamplerShaderBlock *)input_block;
|
|
return (a->sampler_type == b->sampler_type) && a->input[0] && a->input[1] && b->input[0] && b->input[1] ? a->input[0]->IsEquivalent(b->input[0]) && a->input[1]->IsEquivalent(b->input[1]) : false;
|
|
}
|
|
|
|
case ShaderBlock::TypeTexture:
|
|
{
|
|
TextureShaderBlock *a = (TextureShaderBlock *)this, *b = (TextureShaderBlock *)input_block;
|
|
return a->texture == b->texture;
|
|
}
|
|
|
|
case ShaderBlock::TypeGeometryUV:
|
|
{
|
|
GeometryUVShaderBlock *a = (GeometryUVShaderBlock *)this, *b = (GeometryUVShaderBlock *)input_block;
|
|
return a->channel == b->channel;
|
|
}
|
|
|
|
case ShaderBlock::TypeMaterialParam:
|
|
{
|
|
MaterialParamShaderBlock *a = (MaterialParamShaderBlock *)this, *b = (MaterialParamShaderBlock *)input_block;
|
|
return a->param == b->param;
|
|
}
|
|
|
|
case ShaderBlock::TypeClock:
|
|
case ShaderBlock::TypeScreenUV:
|
|
case ShaderBlock::TypeViewVector:
|
|
case ShaderBlock::TypeViewport:
|
|
case ShaderBlock::TypeNormalViewMatrix:
|
|
case ShaderBlock::TypeNormalMatrix:
|
|
case ShaderBlock::TypeModelViewMatrix:
|
|
case ShaderBlock::TypeModelMatrix:
|
|
case ShaderBlock::TypeGeometryVertex:
|
|
case ShaderBlock::TypeGeometrySkinning:
|
|
case ShaderBlock::TypeGeometryNormal:
|
|
case ShaderBlock::TypeGeometryVertexColor:
|
|
case ShaderBlock::TypeGeometryTangentFrame:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
int UnpackColorToVectorShaderBlock::GetOutputType() const
|
|
{ return !input[0] ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
int PackVectorToColorShaderBlock::GetOutputType() const
|
|
{ return !input[0] ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
int MixOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || !input[2] || (input[0]->GetOutputType() != input[1]->GetOutputType()) || (input[2]->GetOutputType() != ShaderInput::Float)) ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
|
|
int DotOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || (input[0]->GetOutputType() != input[1]->GetOutputType())) ? ShaderInput::NoData : ShaderInput::Float; }
|
|
int CrossOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || ((input[0]->GetOutputType() != input[1]->GetOutputType()) && (input[0]->GetOutputType() != ShaderInput::Vector3))) ? ShaderInput::NoData : ShaderInput::Vector3; }
|
|
|
|
int AddOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || (input[0]->GetOutputType() != input[1]->GetOutputType())) ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
int SubOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || (input[0]->GetOutputType() != input[1]->GetOutputType())) ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
int DivOperatorShaderBlock::GetOutputType() const
|
|
{ return (!input[0] || !input[1] || (input[0]->GetOutputType() != input[1]->GetOutputType())) ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
int MulOperatorShaderBlock::GetOutputType() const
|
|
{
|
|
if (!input[0] || !input[1])
|
|
return ShaderInput::NoData;
|
|
|
|
int type_0 = input[0]->GetOutputType(),
|
|
type_1 = input[1]->GetOutputType();
|
|
|
|
if (type_0 > type_1)
|
|
{ int tmp = type_0; type_0 = type_1; type_1 = tmp; }
|
|
|
|
// Switch on largest type.
|
|
switch (type_1)
|
|
{
|
|
case ShaderInput::Matrix3:
|
|
return (type_0 != ShaderInput::Vector3) ? ShaderInput::NoData : ShaderInput::Vector3;
|
|
case ShaderInput::Matrix4:
|
|
return (type_0 != ShaderInput::Vector4) ? ShaderInput::NoData : ShaderInput::Vector4;
|
|
|
|
case ShaderInput::Float:
|
|
case ShaderInput::Vector2:
|
|
case ShaderInput::Vector3:
|
|
case ShaderInput::Vector4:
|
|
return (type_0 != type_1) ? ShaderInput::NoData : type_0;
|
|
}
|
|
return ShaderInput::NoData;
|
|
}
|
|
|
|
int ClampShaderBlock::GetOutputType() const
|
|
{
|
|
if (!input[0] || !input[1] || !input[2])
|
|
return ShaderInput::NoData;
|
|
|
|
int type[3] =
|
|
{
|
|
input[0]->GetOutputType(),
|
|
input[1]->GetOutputType(),
|
|
input[2]->GetOutputType()
|
|
};
|
|
|
|
if (type[1] != type[2]) // min/max must match.
|
|
return ShaderInput::NoData;
|
|
if (type[0] != type[1])
|
|
return ShaderInput::NoData; // input and min/max types must match.
|
|
|
|
return type[0];
|
|
}
|
|
|
|
int NormalizeOperatorShaderBlock::GetOutputType() const
|
|
{ return !input[0] ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------
|
|
int SwizzleShaderBlock::GetOutputType() const
|
|
//-----------------------------------------------------------
|
|
{
|
|
if (!input[0] || (input[0]->GetOutputType() == ShaderInput::NoData))
|
|
return ShaderInput::NoData;
|
|
|
|
int output_count = 0;
|
|
for (int n = 0; n < 4; ++n)
|
|
if (swizzle[n] != SwizzleNone)
|
|
output_count++;
|
|
|
|
switch (output_count)
|
|
{
|
|
case 1: return ShaderInput::Float;
|
|
case 2: return ShaderInput::Vector2;
|
|
case 3: return ShaderInput::Vector3;
|
|
case 4: return ShaderInput::Vector4;
|
|
}
|
|
return ShaderInput::NoData;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
int BuildShaderBlock::GetOutputType() const
|
|
//---------------------------------------------------------
|
|
{
|
|
int output_count = 0;
|
|
for (int n = 0; n < 4; ++n)
|
|
switch (build[n])
|
|
{
|
|
case BuildZero:
|
|
case BuildOne:
|
|
output_count++;
|
|
break;
|
|
|
|
default:
|
|
if (!input[n])
|
|
n = 4;
|
|
else
|
|
{
|
|
if (input[n]->GetOutputType() == ShaderInput::NoData)
|
|
return ShaderInput::NoData;
|
|
output_count++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (output_count)
|
|
{
|
|
case 1: return ShaderInput::Float;
|
|
case 2: return ShaderInput::Vector2;
|
|
case 3: return ShaderInput::Vector3;
|
|
case 4: return ShaderInput::Vector4;
|
|
}
|
|
return ShaderInput::NoData;
|
|
}
|
|
|
|
int CosinusShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Float; }
|
|
int SinusShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Float; }
|
|
int PowShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Float; }
|
|
|
|
int AbsShaderBlock::GetOutputType() const
|
|
{ return !input[0] ? ShaderInput::NoData : input[0]->GetOutputType(); }
|
|
|
|
int GeometryVertexShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector4; }
|
|
int GeometryUVShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector2; }
|
|
int GeometryNormalShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector3; }
|
|
int GeometrySkinningShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix4; }
|
|
int GeometryVertexColorShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector3; }
|
|
int GeometryTangentFrameShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix3; }
|
|
int RenderBufferShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Texture2D; }
|
|
int TextureShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Texture2D; }
|
|
int TextureSamplerShaderBlock::GetOutputType() const
|
|
{ return (input[0] && input[1]) ? ShaderInput::Vector4 : ShaderInput::NoData; }
|
|
int ConstantShaderBlock::GetOutputType() const
|
|
{ return constant_type; }
|
|
|
|
int ColorShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector4; }
|
|
int MaterialParamShaderBlock::GetOutputType() const
|
|
{
|
|
switch (param)
|
|
{
|
|
case MaterialGlossiness:
|
|
case MaterialOpacity:
|
|
case MaterialReflection:
|
|
return ShaderInput::Float;
|
|
}
|
|
return ShaderInput::Vector4;
|
|
}
|
|
int MaterialTextureShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Texture2D; }
|
|
|
|
int ScreenUVShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector2; }
|
|
int ViewVectorShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector3; }
|
|
int ViewportShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Vector4; }
|
|
|
|
int NormalViewMatrixShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix3; }
|
|
int NormalMatrixShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix3; }
|
|
int ModelViewMatrixShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix4; }
|
|
int ModelMatrixShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Matrix4; }
|
|
|
|
int ClockShaderBlock::GetOutputType() const
|
|
{ return ShaderInput::Float; }
|