commit x64 compilation from lulu cause the other branch dont seems to compile properly at home
This commit is contained in:
296
include/modules/raytracer/shader_tree_cpu.cpp
Normal file
296
include/modules/raytracer/shader_tree_cpu.cpp
Normal file
@ -0,0 +1,296 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
GSFramework
|
||||
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
||||
----------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
#include <cmath>
|
||||
#include "raytracer/raytracer_core.h"
|
||||
#include "core/shader_block.h"
|
||||
#include "core/geometry.h"
|
||||
#include "core/object.h"
|
||||
|
||||
using namespace GS::Core;
|
||||
using namespace GS::Raytrace;
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
bool Raytracer::EvaluateShaderBlock(const Trace &trace, const ShaderBlock *block, ShaderBlockValue &out)
|
||||
{
|
||||
ShaderBlockValue in[4]; // No more than 4 inputs supported.
|
||||
|
||||
// Validity check.
|
||||
if (!block)
|
||||
return true;
|
||||
|
||||
// Evaluate inputs.
|
||||
for (uint n = 0; n < block->GetInputCount(); ++n)
|
||||
if (!EvaluateShaderBlock(trace, block->GetInput(n), in[n]))
|
||||
return false;
|
||||
|
||||
// Evaluate block.
|
||||
switch (block->type)
|
||||
{
|
||||
case ShaderBlock::TypeGeometryVertex:
|
||||
out.Set(trace.pi * trace.o->GetInverseMatrix());
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeGeometryNormal:
|
||||
if (Vector4 *nrm = trace.g->vtx_normal)
|
||||
{
|
||||
Vector4 &nm0 = nrm[trace.bi],
|
||||
&nm1 = nrm[trace.bi + trace.it + 1],
|
||||
&nm2 = nrm[trace.bi + trace.it + 2];
|
||||
|
||||
out.Set(nm0 * trace.w + nm1 * trace.u + nm2 * trace.v);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeGeometryVertexColor:
|
||||
if (Vector4 *rgb = trace.g->rgb)
|
||||
{
|
||||
Vector4 &cl0 = rgb[trace.bi],
|
||||
&cl1 = rgb[trace.bi + trace.it + 1],
|
||||
&cl2 = rgb[trace.bi + trace.it + 2];
|
||||
|
||||
out.Set(cl0 * trace.w + cl1 * trace.u + cl2 * trace.v);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeGeometryUV:
|
||||
{
|
||||
GeometryUVShaderBlock *b = (GeometryUVShaderBlock *)block;
|
||||
|
||||
if (Vector2 *uv = trace.g->uv[b->channel])
|
||||
{
|
||||
Vector2 &uv0 = uv[trace.bi],
|
||||
&uv1 = uv[trace.bi + trace.it + 1],
|
||||
&uv2 = uv[trace.bi + trace.it + 2];
|
||||
|
||||
out.Set(Vector4(trace.w * uv0.x + trace.u * uv1.x + trace.v * uv2.x, trace.w * uv0.y + trace.u * uv1.y + trace.v * uv2.y, 0, 0));
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeGeometrySkinning:
|
||||
break;
|
||||
case ShaderBlock::TypeGeometryTangentFrame:
|
||||
{
|
||||
Vector4 sample = ( trace.g->vtx_normal[trace.bi] * trace.w +
|
||||
trace.g->vtx_normal[trace.bi + trace.it + 1] * trace.u +
|
||||
trace.g->vtx_normal[trace.bi + trace.it + 2] * trace.v ).Normalized();
|
||||
|
||||
Vector4 T, B;
|
||||
|
||||
if (trace.g->vtx_tangent)
|
||||
{
|
||||
// Interpolated tangent basis.
|
||||
T = (trace.g->vtx_tangent[trace.bi + 0].T * trace.w +
|
||||
trace.g->vtx_tangent[trace.bi + trace.it + 1].T * trace.u +
|
||||
trace.g->vtx_tangent[trace.bi + trace.it + 2].T * trace.v ).Normalized();
|
||||
B = (trace.g->vtx_tangent[trace.bi + 0].B * trace.w +
|
||||
trace.g->vtx_tangent[trace.bi + trace.it + 1].B * trace.u +
|
||||
trace.g->vtx_tangent[trace.bi + trace.it + 2].B * trace.v ).Normalized();
|
||||
}
|
||||
else
|
||||
{
|
||||
T.Set(1, 0, 0);
|
||||
B.Set(0, 1, 0);
|
||||
}
|
||||
|
||||
// Build tangent frame.
|
||||
Matrix3 tangent_matrix(T, B, sample);
|
||||
out.Set(tangent_matrix);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeTexture:
|
||||
out.Set(((TextureShaderBlock *)block)->texture);
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeTextureSampler:
|
||||
{
|
||||
if (in[0].t)
|
||||
{
|
||||
Color sample;
|
||||
if (Picture *p = gf->LoadPicture(in[0].t))
|
||||
p->SampleRGBA(in[1].v.x < 0 ? 1 + fmodf(in[1].v.x, 1) : fmodf(in[1].v.x, 1), in[1].v.y < 0 ? 1 + fmodf(in[1].v.y, 1) : fmodf(in[1].v.y, 1), sample);
|
||||
out.Set(sample);
|
||||
}
|
||||
else
|
||||
out.Set(Vector4(0, 0, 0));
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeConstant:
|
||||
{
|
||||
ConstantShaderBlock *b = (ConstantShaderBlock *)block;
|
||||
out.Set(Vector4(b->constant[0], b->constant[1], b->constant[2], b->constant[3]));
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeColor:
|
||||
{
|
||||
ColorShaderBlock *b = (ColorShaderBlock *)block;
|
||||
out.Set(b->color);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeMaterialParam:
|
||||
{
|
||||
MaterialParamShaderBlock *b = (MaterialParamShaderBlock *)block;
|
||||
switch (b->param)
|
||||
{
|
||||
case MaterialParamShaderBlock::MaterialAmbient:
|
||||
out.Set(trace.m->ambient);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialDiffuse:
|
||||
out.Set(trace.m->diffuse);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialSpecular:
|
||||
out.Set(trace.m->specular);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialSelf:
|
||||
out.Set(trace.m->self);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialGlossiness:
|
||||
out.Set(trace.m->glossiness);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialOpacity:
|
||||
out.Set(trace.m->opacity);
|
||||
break;
|
||||
case MaterialParamShaderBlock::MaterialReflection:
|
||||
out.Set(trace.m->reflection);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeScreenUV:
|
||||
out.Set(Vector4(0.5f,0.5f,0.5f));
|
||||
break;
|
||||
case ShaderBlock::TypeViewVector:
|
||||
out.Set(trace.d);
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeNormalViewMatrix:
|
||||
out.Set(Matrix3::FromOrthonormalBasis(trace.d).Transposed() * trace.o->GetRotationMatrix());
|
||||
break;
|
||||
case ShaderBlock::TypeNormalMatrix:
|
||||
out.Set(trace.o->GetRotationMatrix());
|
||||
break;
|
||||
case ShaderBlock::TypeModelViewMatrix:
|
||||
{
|
||||
Matrix4 view_matrix = Matrix4::FromMatrix3(Matrix3::FromOrthonormalBasis(trace.d).Transposed());
|
||||
view_matrix.SetRow(3, trace.s.Reversed());
|
||||
out.Set(view_matrix * trace.o->GetMatrix());
|
||||
}
|
||||
break;
|
||||
case ShaderBlock::TypeModelMatrix:
|
||||
out.Set(trace.o->GetMatrix());
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeMix: out.Set(in[0].v * in[2].v.x + in[1].v * (1 - in[2].v.x)); break;
|
||||
case ShaderBlock::TypeAdd: out.Set(in[0].v + in[1].v); break;
|
||||
case ShaderBlock::TypeMul:
|
||||
{
|
||||
if (in[0].type == in[1].type)
|
||||
switch (in[0].type)
|
||||
{
|
||||
case ShaderBlockValue::BlockValueVector: out.Set(in[0].v * in[1].v); break;
|
||||
case ShaderBlockValue::BlockValueMatrix3: out.Set(in[0].m3 * in[1].m3); break;
|
||||
case ShaderBlockValue::BlockValueMatrix4: out.Set(in[0].m4 * in[1].m4); break;
|
||||
}
|
||||
else
|
||||
{
|
||||
ShaderBlockValue *_a = &in[0], *_b = &in[1];
|
||||
if (_b->type < _a->type)
|
||||
{ ShaderBlockValue *tmp = _a; _a = _b; _b = tmp; }
|
||||
|
||||
if (_a->type == ShaderBlockValue::BlockValueVector)
|
||||
{
|
||||
if (_b->type == ShaderBlockValue::BlockValueMatrix3)
|
||||
out.Set(_a->v * _b->m3);
|
||||
else if (_b->type == ShaderBlockValue::BlockValueMatrix4)
|
||||
out.Set(_a->v * _b->m4);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeSub: out.Set(in[0].v - in[1].v); break;
|
||||
case ShaderBlock::TypeDiv: out.Set(in[0].v / in[1].v); break;
|
||||
|
||||
case ShaderBlock::TypeDot: out.Set(in[0].v.Dot(in[1].v)); break;
|
||||
case ShaderBlock::TypeCross: out.Set(in[0].v.Cross(in[1].v)); break;
|
||||
|
||||
case ShaderBlock::TypeClamp:
|
||||
out.Set(Vector4(
|
||||
Types::Clamp(in[0].v.x, in[1].v.x, in[2].v.x),
|
||||
Types::Clamp(in[0].v.y, in[1].v.y, in[2].v.y),
|
||||
Types::Clamp(in[0].v.z, in[1].v.z, in[2].v.z),
|
||||
Types::Clamp(in[0].v.w, in[1].v.w, in[2].v.w) ) );
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeNormalize: out.Set(in[0].v.Normalized()); break;
|
||||
|
||||
case ShaderBlock::TypeSwizzle:
|
||||
{
|
||||
SwizzleShaderBlock *b = (SwizzleShaderBlock *)block;
|
||||
|
||||
Vector4 v(0, 0, 0);
|
||||
for (int n = 0; n < 4; ++n)
|
||||
if (b->swizzle[n] != SwizzleShaderBlock::SwizzleNone)
|
||||
v[n] = in[0].v[b->swizzle[n] - SwizzleShaderBlock::SwizzleX];
|
||||
|
||||
out.Set(v);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeBuild:
|
||||
{
|
||||
BuildShaderBlock *b = (BuildShaderBlock *)block;
|
||||
|
||||
Vector4 v(0, 0, 0);
|
||||
for (int n = 0; n < 4; ++n)
|
||||
{
|
||||
if (b->build[n] == BuildShaderBlock::BuildOne)
|
||||
v[n] = 1;
|
||||
else if (b->build[n] == BuildShaderBlock::BuildZero)
|
||||
v[n] = 0;
|
||||
else v[n] = in[n].v[b->build[n] - BuildShaderBlock::BuildX];
|
||||
}
|
||||
|
||||
out.Set(v);
|
||||
}
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeSin: out.Set(sin(in[0].v.x)); break;
|
||||
case ShaderBlock::TypeCos: out.Set(cos(in[0].v.x)); break;
|
||||
|
||||
case ShaderBlock::TypeUnpackColorToVector:
|
||||
out.Set((in[0].v - Vector4(0.5, 0.5, 0.0)) * Vector4(2.0, 2.0, 1.0));
|
||||
break;
|
||||
case ShaderBlock::TypePackVectorToColor:
|
||||
out.Set((in[0].v + Vector4(1.0, 1.0, 0.0)) * Vector4(0.5, 0.5, 1.0));
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeClock:
|
||||
out.Set(render_clock);
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypePow:
|
||||
out.Set(float(pow(in[0].v.x, in[1].v.x)));
|
||||
break;
|
||||
|
||||
case ShaderBlock::TypeAbs:
|
||||
if (in[0].type == ShaderBlockValue::BlockValueVector)
|
||||
{
|
||||
Vector4 o = in[0].v.Abs();
|
||||
out.Set(Vector4(o.x, o.y, o.z));
|
||||
}
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
Reference in New Issue
Block a user