void GameObjectMaterialComponentsWidget::on_m_VSPropsButton_clicked()
{
if(!m_IsReady)
{
return;
}
MeshMaterialGOC* meshMat = GetMeshMaterialGOC();
if(meshMat == nullptr)
{
return;
}
VertexShader* vs = meshMat->GetVertexShaderResource();
if(vs == nullptr)
{
return;
}
ShaderProperties* vsProps = meshMat->GetVertexShaderProperties();
GameObjectShaderPropsDialog shaderPropsDiag(meshMat->GetName(), vs->GetName(), m_GameApp->GetGameAssetManager(), vsProps);
shaderPropsDiag.exec();
}
static Program make_prog(void)
{
Program prog;
VertexShader vs;
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"mat4 Matrix = ProjectionMatrix*CameraMatrix*ModelMatrix;"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = Matrix*Position;"
"}"
);
FragmentShader fs;
fs.Source(
"#version 330\n"
"void main(void){ }"
);
prog.AttachShader(vs).AttachShader(fs);
prog.Link().Validate().Use();
return std::move(prog);
}
static Program make(void)
{
Program prog;
VertexShader vs;
vs.Source(
"#version 330\n"
"uniform vec2 ScreenSize;"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = TexCoord*ScreenSize;"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"uniform sampler1D Palette;"
"uniform sampler2DRect Tex;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float Overdraw = texture(Tex, vertTexCoord).r;"
" fragColor = texture(Palette, Overdraw);"
"}"
).Compile();
prog.AttachShader(vs).AttachShader(fs).Link().Use();
return std::move(prog);
}
static Program make(void)
{
VertexShader vs;
vs.Source(
"#version 330\n"
"uniform mat4 CameraMatrix,ModelMatrix;"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = CameraMatrix * ModelMatrix * Position;"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"void main(void)"
"{"
"}"
).Compile();
Program prog;
prog << vs << fs;
prog.Link().Use();
return std::move(prog);
}
// Makes the common shared vertex shader
static VertexShader make_vs(void)
{
VertexShader shader;
shader.Source(
"#version 140\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vertTexCoord = TexCoord;"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos - gl_Position.xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
shader.Compile();
return shader;
}
static Program make(void)
{
Program prog;
VertexShader vs;
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"layout (std140) uniform OffsetBlock {vec3 Offset[16*16*16];};"
"in vec3 Position;"
"void main(void)"
"{"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(Position+Offset[gl_InstanceID], 1.0);"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"out float fragValue;"
"void main(void)"
"{"
" fragValue = 1.0/16.0;"
"}"
).Compile();
prog.AttachShader(vs).AttachShader(fs).Link().Use();
return std::move(prog);
}
void ShaderManager<RS>::init()
{
//construct safe default shader
VertexShader<RS>* dv = 0;
FragmentShader<RS>* df = 0;
dv = new VertexShader<RS>();
df = new FragmentShader<RS>();
Vertex def;
def.addVector3("POSITION");
def.finalize();
dv->associateVertex(def);
if(RS == RS_DX11)
{
dv->initFromDef(Defaults::shaderDefDX, Defaults::vertexFunc);
df->initFromDef(Defaults::shaderDefDX, Defaults::fragmentFunc);
}
else
{
dv->initFromDef(Defaults::shaderDefGL, Defaults::vertexFunc);
df->initFromDef(Defaults::shaderDefGL, Defaults::fragmentFunc);
}
vShaders[Defaults::mapName][Defaults::mapName] = dv;
fShaders[Defaults::mapName][Defaults::mapName] = df;
}
bool MicroManagerTest::initalize(float width, float height)
{
VertexShader vertexShader;
vertexShader.set( mData->sManager.loadVertexFromFile(&md3d, L"EngineVSPosNormalUV") );
mData->ps = mData->sManager.loadPixelFromFile(&md3d, L"PSPosNormalUV");
VertexShaderHandle modelShader = VertexShaderManager::newVertexShader( vertexShader );
md3d.getDeviceContext()->PSSetShader(mData->ps,NULL,NULL);
Procedural::MeshBuilderType mbt;
Procedural::BoxGenerator bg;
bg.addToMeshBuilder( mbt );
auto mesh = mbt.toMeshVertexCPU();
mData->model = ModelBuilder::makeStaticGeometryModel( md3d, VertexTypeManager::getVertexType(VertexTypeManager::Pos_Normal_UV), D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, mesh->toMeshCPU() );
ModelManager::fromHandle(mData->model).mVSShader = modelShader;
mbt.clear();
Procedural::SphereGenerator sg(1,128,128);
sg.addToMeshBuilder( mbt );
auto meshSphere = mbt.toMeshVertexCPU();
mData->sphere = ModelBuilder::makeStaticGeometryModel( md3d, VertexTypeManager::getVertexType(VertexTypeManager::Pos_Normal_UV), D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, meshSphere->toMeshCPU() );
ModelManager::fromHandle(mData->sphere).mVSShader = modelShader;
mData->cam.setPerspectiveFOV( DirectX::XMConvertToRadians(45),width / height, 0.1, 500 );
mData->cam.lookAt( .0f,.0f,.0f );
mData->cam.setPosition( .0f, .0f, -30.0f );
mData->cam.setRotationEuler( .0f,.0f,.0f);
int count = 0;
MaterialHandle fakeMaterial;
// Generate the box Array and positions
for( float xPos = -10.0f; xPos < 10.0f; xPos += 2.0f )
{
for( float yPos = -10.0f; yPos < 10.0f; yPos += 2.0f )
{
count++;
BoxDemo2 bx = {xPos, yPos, 0.0f, 0.0f, 0.0f, 0.0f, mData->mang->newRi( count % 2 == 0 ? mData->model : mData->sphere, fakeMaterial )};
mData->boxes.push_back( bx );
}
}
mIsOk = true;
matrix proj;
mData->cam.getProjData( &proj );
mData->mang->displayUpdate( proj );
return mIsOk;
}
ShaderProgram::ShaderProgram(
const string &filename,
const VertexShader &vertexShader,
const FragmentShader &fragmentShader) : _name(filename), _handle(0), _linked(0)
{
try
{
if (vertexShader.fail()) throw std::runtime_error("Invalid vertex shader");
if (fragmentShader.fail()) throw std::runtime_error("Invalid fragment shader");
if (GLEW_VERSION_2_0)
{
// Create program and attach vertex and fragment shaders
_handle = glCreateProgram();
glAttachShader(_handle, vertexShader.handle());
glAttachShader(_handle, fragmentShader.handle());
// Perform link stage
glLinkProgram(_handle);
glGetProgramiv(_handle, GL_LINK_STATUS, &_linked);
// Validate program
glValidateProgram(_handle);
printInfoLog();
// Check for success
if (GL_FALSE == _linked)
throw std::runtime_error("Link stage failed");
}
else if (GLEW_VERSION_1_5)
{
// Create program and attach vertex and fragment shaders
_handle = glCreateProgramObjectARB();
glAttachObjectARB(_handle, vertexShader.handle());
glAttachObjectARB(_handle, fragmentShader.handle());
// Perform link stage
glLinkProgramARB(_handle);
glGetObjectParameterivARB(_handle, GL_OBJECT_LINK_STATUS_ARB, &_linked);
// Validate program
glValidateProgramARB(_handle);
printInfoLog();
// Check for success
if (GL_FALSE == _linked)
throw std::runtime_error("Link stage failed");
}
cout << "* Shader \"" << _name << "\" successfully linked" << endl;
}
catch (std::runtime_error &err)
{
cerr << "Error: Faild to create shader " << _name << endl;
cerr << "Reason: " << err.what() << endl;
}
}
static Program make_prog(void)
{
VertexShader vs;
vs.Source(
"#version 130\n"
"uniform mat4 ProjectionMatrix, ModelMatrix, CameraMatrix;"
"uniform vec4 ClipPlane;"
"attribute vec4 Position;"
"attribute vec2 TexCoord;"
"varying vec2 vertTexCoord;"
"void main(void)"
"{"
" vertTexCoord = TexCoord;"
" gl_Position = "
" ModelMatrix *"
" Position;"
" gl_ClipDistance[0] = dot(ClipPlane, gl_Position);"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" gl_Position;"
"}"
);
vs.Compile();
FragmentShader fs;
fs.Source(
"#version 130\n"
"varying vec2 vertTexCoord;"
"void main(void)"
"{"
" float i = ("
" int(vertTexCoord.x*36) % 2+"
" int(vertTexCoord.y*24) % 2"
" ) % 2;"
" if(gl_FrontFacing)"
" {"
" gl_FragColor = vec4(1-i/2, 1-i/2, 1-i/2, 1.0);"
" }"
" else"
" {"
" gl_FragColor = vec4(0+i/2, 0+i/2, 0+i/2, 1.0);"
" }"
"}"
);
fs.Compile();
Program prog;
prog.AttachShader(vs);
prog.AttachShader(fs);
prog.Link();
prog.Use();
return prog;
}
//----------------------------------------------------------------------------
void LightAmbEffect::PostLink ()
{
VisualEffect::PostLink();
VisualPass* pass = mTechniques[0]->GetPass(0);
VertexShader* vshader = pass->GetVertexShader();
PixelShader* pshader = pass->GetPixelShader();
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
pshader->SetPrograms(msPPrograms);
}
//----------------------------------------------------------------------------
void Texture2ColorBlendEffect::PostLink ()
{
VisualEffect::PostLink();
VisualPass* pass = mTechniques[0]->GetPass(0);
VertexShader* vshader = pass->GetVertexShader();
PixelShader* pshader = pass->GetPixelShader();
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
pshader->SetTextureUnits(msPTextureUnits);
pshader->SetPrograms(msPPrograms);
}
//----------------------------------------------------------------------------
VertexShader* VertexShader::Load (const char* acFilename)
{
// open stream, load
ifstream kIStr(acFilename,ios::in|ios::binary);
if ( !kIStr )
return NULL;
VertexShader* pkShader = new VertexShader;
pkShader->Read(kIStr);
kIStr.close();
return pkShader;
}
//----------------------------------------------------------------------------
void JunglerMaterial::PostLink ()
{
Material::PostLink();
MaterialPass* pass = mTechniques[0]->GetPass(0);
VertexShader* vshader = pass->GetVertexShader();
PixelShader* pshader = pass->GetPixelShader();
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
pshader->SetTextureUnits(msPTextureUnits);
pshader->SetPrograms(msPPrograms);
}
/**
* @brief
* Creates a vertex shader and sets the shader source code
*/
VertexShader *ShaderLanguage::CreateVertexShader(const String &sSourceCode, const String &sProfile, const String &sArguments, const String &sEntry)
{
// Create the vertex shader instance
VertexShader *pVertexShader = CreateVertexShader();
// Set the vertex shader source code
if (pVertexShader)
pVertexShader->SetSourceCode(sSourceCode, sProfile, sArguments, sEntry);
// Return the created vertex shader instance
return pVertexShader;
}
//----------------------------------------------------------------------------
VertexColor4TextureEffect::VertexColor4TextureEffect (
Shader::SamplerFilter filter, Shader::SamplerCoordinate coordinate0,
Shader::SamplerCoordinate coordinate1)
{
VertexShader* vshader = new0 VertexShader("Wm5.VertexColorTexture",
3, 3, 1, 0, false);
vshader->SetInput(0, "modelPosition", Shader::VT_FLOAT3,
Shader::VS_POSITION);
vshader->SetInput(1, "modelTCoord", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
vshader->SetInput(2, "modelColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
vshader->SetOutput(0, "clipPosition", Shader::VT_FLOAT4,
Shader::VS_POSITION);
vshader->SetOutput(1, "vertexTCoord", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
vshader->SetOutput(2, "vertexColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
vshader->SetConstant(0, "PVWMatrix", 4);
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
PixelShader* pshader = new0 PixelShader("Wm5.VertexColorTexture",
2, 1, 0, 1, false);
pshader->SetInput(0, "vertexColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
pshader->SetInput(1, "vertexTCoord", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
pshader->SetOutput(0, "pixelColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
pshader->SetSampler(0, "BaseSampler", Shader::ST_2D);
pshader->SetFilter(0, filter);
pshader->SetCoordinate(0, 0, coordinate0);
pshader->SetCoordinate(0, 1, coordinate1);
pshader->SetTextureUnits(msPTextureUnits);
pshader->SetPrograms(msPPrograms);
VisualPass* pass = new0 VisualPass();
pass->SetVertexShader(vshader);
pass->SetPixelShader(pshader);
pass->SetAlphaState(new0 AlphaState());
pass->SetCullState(new0 CullState());
pass->SetDepthState(new0 DepthState());
pass->SetOffsetState(new0 OffsetState());
pass->SetStencilState(new0 StencilState());
pass->SetWireState(new0 WireState());
VisualTechnique* technique = new0 VisualTechnique();
technique->InsertPass(pass);
InsertTechnique(technique);
}
//----------------------------------------------------------------------------
LightSptPerPixEffect::LightSptPerPixEffect ()
{
VertexShader* vshader = new0 VertexShader("Wm5.LightSptPerPix",
2, 3, 1, 0, false);
vshader->SetInput(0, "modelPosition", Shader::VT_FLOAT3,
Shader::VS_POSITION);
vshader->SetInput(1, "modelNormal", Shader::VT_FLOAT3,
Shader::VS_TEXCOORD1);
vshader->SetOutput(0, "clipPosition", Shader::VT_FLOAT4,
Shader::VS_POSITION);
vshader->SetOutput(1, "vertexPosition", Shader::VT_FLOAT3,
Shader::VS_TEXCOORD0);
vshader->SetOutput(2, "vertexNormal", Shader::VT_FLOAT3,
Shader::VS_TEXCOORD1);
vshader->SetConstant(0, "PVWMatrix", 4);
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
PixelShader* pshader = new0 PixelShader("Wm5.LightSptPerPix",
2, 1, 13, 0, false);
pshader->SetInput(0, "vertexPosition", Shader::VT_FLOAT3,
Shader::VS_TEXCOORD0);
pshader->SetInput(1, "vertexNormal", Shader::VT_FLOAT3,
Shader::VS_TEXCOORD1);
pshader->SetOutput(0, "pixelColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
pshader->SetConstant(0, "WMatrix", 4);
pshader->SetConstant(1, "CameraModelPosition", 1);
pshader->SetConstant(2, "MaterialEmissive", 1);
pshader->SetConstant(3, "MaterialAmbient", 1);
pshader->SetConstant(4, "MaterialDiffuse", 1);
pshader->SetConstant(5, "MaterialSpecular", 1);
pshader->SetConstant(6, "LightModelPosition", 1);
pshader->SetConstant(7, "LightModelDirection", 1);
pshader->SetConstant(8, "LightAmbient", 1);
pshader->SetConstant(9, "LightDiffuse", 1);
pshader->SetConstant(10, "LightSpecular", 1);
pshader->SetConstant(11, "LightSpotCutoff", 1);
pshader->SetConstant(12, "LightAttenuation", 1);
pshader->SetBaseRegisters(msPRegisters);
pshader->SetPrograms(msPPrograms);
VisualPass* pass = new0 VisualPass();
pass->SetVertexShader(vshader);
pass->SetPixelShader(pshader);
pass->SetAlphaState(new0 AlphaState());
pass->SetCullState(new0 CullState());
pass->SetDepthState(new0 DepthState());
pass->SetOffsetState(new0 OffsetState());
pass->SetStencilState(new0 StencilState());
pass->SetWireState(new0 WireState());
VisualTechnique* technique = new0 VisualTechnique();
technique->InsertPass(pass);
InsertTechnique(technique);
}
void PipelineStateCache::setVertexShader(const VertexShader& vertexShader)
{
// FIXME: cache this
ID3D11Buffer* const* constantBuffers;
uint32 numConstantBuffers = vertexShader.queryBuffersArray(constantBuffers);
m_deviceContext->VSSetConstantBuffers(0, numConstantBuffers, constantBuffers);
ID3D11VertexShader* shaderResourcePtr = vertexShader.getResourcePtr();
if (shaderResourcePtr != m_currentVertexShader)
{
m_currentVertexShader = shaderResourcePtr;
m_deviceContext->VSSetShader(shaderResourcePtr, NULL, 0);
}
}
//----------------------------------------------------------------------------
UIMaterial::UIMaterial ()
{
VertexShader* vshader = new0 VertexShader("PX2.UI",
3, 3, 1, 0, false);
vshader->SetInput(0, "modelPosition", Shader::VT_FLOAT3,
Shader::VS_POSITION);
vshader->SetInput(1, "modelColor0", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
vshader->SetInput(2, "modelTCoord0", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
vshader->SetOutput(0, "clipPosition", Shader::VT_FLOAT4,
Shader::VS_POSITION);
vshader->SetOutput(1, "vertexColor0", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
vshader->SetOutput(2, "vertexTCoord0", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
vshader->SetConstant(0, "gPVWMatrix", 4);
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
PixelShader* pshader = new0 PixelShader("PX2.UI",
2, 1, 0, 1, false);
pshader->SetInput(0, "vertexColor0", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
pshader->SetInput(1, "vertexTCoord0", Shader::VT_FLOAT2,
Shader::VS_TEXCOORD0);
pshader->SetOutput(0, "pixelColor", Shader::VT_FLOAT4,
Shader::VS_COLOR0);
pshader->SetSampler(0, "gDiffuseSampler", Shader::ST_2D);
pshader->SetFilter(0, Shader::SF_NEAREST);
pshader->SetCoordinate(0, 0, Shader::SC_CLAMP_EDGE);
pshader->SetCoordinate(0, 1, Shader::SC_CLAMP_EDGE);
pshader->SetTextureUnits(msPTextureUnits);
pshader->SetPrograms(msPPrograms);
MaterialPass* pass = new0 MaterialPass();
pass->SetVertexShader(vshader);
pass->SetPixelShader(pshader);
pass->SetAlphaProperty(new0 AlphaProperty());
pass->SetCullProperty(new0 CullProperty());
pass->SetDepthProperty(new0 DepthProperty());
pass->SetOffsetProperty(new0 OffsetProperty());
pass->SetStencilProperty(new0 StencilProperty());
pass->SetWireProperty(new0 WireProperty());
pass->GetAlphaProperty()->BlendEnabled = true;
MaterialTechnique* technique = new0 MaterialTechnique();
technique->InsertPass(pass);
InsertTechnique(technique);
}
VertexShader<RS>* ShaderManager<RS>::getVertexShader(const String& file, const String&
function, const Vertex* p)
{
VertexShader<RS>* out = 0;
auto f = vShaders.find(file);
if(f != vShaders.end())
{
auto fn = (*f).second.find(function);
if(fn != (*f).second.end())
{
out = (*fn).second;
}
else
{
out = new VertexShader<RS>();
if(p)
out->associateVertex(*p);
try
{
out->Shader::init(file, function);
vShaders[file][function] = out;
}
catch(DeviceFailureException e)
{
LOG(e.what());
out->destroy();
out = vShaders[Defaults::mapName][Defaults::mapName];
}
}
}
else
{
vShaders[file] = HashMap<String,VertexShader<RS>*>();
out = new VertexShader<RS>();
if(p)
out->associateVertex(*p);
try
{
out->Shader::init(file, function);
vShaders[file][function] = out;
}
catch(DeviceFailureException e)
{
LOG(e.what());
out->destroy();
out = vShaders[Defaults::mapName][Defaults::mapName];
}
}
return out;
}
//----------------------------------------------------------------------------
void StandardESMaterial_AlphaTest::PostLink ()
{
Material::PostLink();
MaterialPass* pass = mTechniques[0]->GetPass(0);
VertexShader* vshader = pass->GetVertexShader();
PixelShader* pshader = pass->GetPixelShader();
vshader->SetBaseRegisters(msVRegisters);
vshader->SetPrograms(msVPrograms);
pshader->SetTextureUnits(msPTextureUnits);
pshader->SetPrograms(msPPrograms);
vshader->SetShaderKey(SKT_STANNDES_ALPHATEST);
pshader->SetShaderKey(SKT_STANNDES_ALPHATEST);
}
const unsigned int ShaderCache::getVertexShader(const tinyxml2::XMLElement* element, const DeviceManager& deviceManager)
{
VertexShader shader;
shader.deserialise(element);
unsigned int resourceName = hashString(getResourceNameFromFileName(shader.getFileName()));
if (getVertexShader(resourceName) == nullptr)
{
if (shader.createShader(deviceManager))
{
m_vertexShaders.emplace(VertexShaderHandle(resourceName, shader));
}
}
return resourceName;
}
ShaderProgram::ShaderProgram(const char *pFragmentFile, const char *pVertexFile)
{
Init();
FragmentShader *pFragmentShader = new FragmentShader(pFragmentFile);
VertexShader *pVertexShader = new VertexShader(pVertexFile);
SetFragmentShader(pFragmentShader);
SetVertexShader(pVertexShader);
pFragmentShader->Release();
pVertexShader->Release();
CreateProgram();
}
static oglplus::Program make_prog(void)
{
using namespace oglplus;
Program prog;
VertexShader vs;
vs.Source(
"#version 140\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform vec3 LightPos;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 140\n"
"uniform sampler2D Checker;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = dot(vertNormal, normalize(vertLight));"
" float i = 0.4 + 1.4*max(d, 0.0);"
" vec4 t = texture(Checker, vertTexCoord);"
" fragColor = vec4(t.rrr*i, 1.0);"
"}"
).Compile();
prog.AttachShader(vs).AttachShader(fs).Link().Use();
return prog;
}
UserInterface::UserInterface(float inRange) : mRange(inRange), mRatio(0.0f),
mMouseX(0.0f), mMouseY(0.0f), mMouseOverWidget(NULL),
mClickCandidate(NULL), mModelViewProjection(mMatrix)
{
if (mRange < 1.0f) mRange = 1.0f;
VertexShader vs;
const char* vertexShader =
"#version 120\n"
"uniform mat4 uMVPM;\n"
"attribute vec2 iPosition;\n"
"attribute vec2 iTexture;\n"
"varying vec2 vTexture;\n"
"void main(void)\n"
"{\n"
" vTexture = iTexture;\n"
" vec4 p = vec4(iPosition, 0.0, 1.0);\n"
" gl_Position = uMVPM * p;\n"
"}\n"
;
vs.loadFromBuffer(vertexShader);
FragmentShader fs;
const char* fragmentShader =
"#version 120\n"
"uniform sampler2D uTexture;\n"
"varying vec2 vTexture;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(uTexture, vTexture);\n"
"}\n"
;
fs.loadFromBuffer(fragmentShader);
mProgram.attachShader(vs);
mProgram.attachShader(fs);
mProgram.bindAttribLocation(0, "iVertex");
mProgram.bindAttribLocation(1, "iTexture");
mProgram.link();
mUniMVPM = mProgram.getUniformLocation("uMVPM");
mUniTexture = mProgram.getUniformLocation("uTexture");
glUniform1i(mUniTexture, 0);
}
ShaderProgram* WindowsGame::createShaderProgram()
{
ShaderProgram* program = new ShaderProgram();
VertexShader vertexShader;
vertexShader.initialize(graphicsDevice, VertexShaderSource, sizeof(VertexShaderSource));
PixelShader pixelShader;
pixelShader.initialize(graphicsDevice, PixelShaderSource, sizeof(PixelShaderSource));
program->initialize(graphicsDevice);
program->setVertexShader(&vertexShader);
program->setPixelShader(&pixelShader);
return program;
}
//==============================================================================
VertexShader * CGraphicsMgr::LoadVertexShader (
const std::wstring & name,
const std::wstring & filepath,
const std::string & entryFunction,
const D3D11_INPUT_ELEMENT_DESC * inputDesc,
unsigned inputElementCount
) {
VertexShader * shader = FindVertexShaderRaii(name);
if (!shader->Compile(name, filepath, entryFunction, inputDesc, inputElementCount))
return nullptr;
return shader;
}
static Program make_prog(void)
{
VertexShader vs;
vs.Source(
"#version 330\n"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertColor;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertColor = abs(normalize(Normal+vec3(1, 1, 1)));"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos - gl_Position.xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
vs.Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"in vec3 vertColor;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = dot(vertLight, vertLight);"
" float d = l > 0.0 ? dot(vertNormal, normalize(vertLight)) / l : 0.0;"
" float i = 0.2 + max(d*3.2, 0.0);"
" fragColor = vec4(vertColor*i, 1.0);"
"}"
);
fs.Compile();
Program prog;
prog.AttachShader(vs);
prog.AttachShader(fs);
prog.Link();
return prog;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
Ptr<GPUProgram> Context::CreateGPUProgram( LPCTSTR VertexShaderSource, LPCTSTR FragmentShaderSource )
{
VertexShader* pVertexShader = 0;
FragmentShader* pFragmentShader = 0;
if (VertexShaderSource)
{
pVertexShader = new VertexShader(this);
pVertexShader->Compile(VertexShaderSource);
}
if (FragmentShaderSource)
{
pFragmentShader = new FragmentShader(this);
pFragmentShader->Compile(FragmentShaderSource);
}
return CreateGPUProgram( pVertexShader, pFragmentShader );
}
const RightDrawer::WaterPlaneShaderProgramAndParameters& RightDrawer::getWaterPlaneProgram(WaterPlaneShaderProgramIndex params)
{
boolean bNew;
auto it = waterPlaneShaderPrograms.insert(bNew, params);
if(!bNew)
return *it->val;
it->val = new WaterPlaneShaderProgramAndParameters();
boolean bNewPS;
auto psIt = waterPlanePixelShaders.insert(bNewPS, params.ps);
PixelShader* ps;
if(bNewPS){
ps = new PixelShader(*this);
String code = getWaterPlanePixelShaderCode(params.ps);
ps->init(code);
psIt->val = ps;
}
else
ps = psIt->val;
boolean bNewVS;
auto vsIt = meshVertexShaders.insert(bNewVS, params.vs);
VertexShader* vs;
if(bNewVS){
vs = new VertexShader(*this);
String code = getMeshVertexShaderCode(params.vs);
vs->init(code);
vsIt->val = vs;
}
else
vs = vsIt->val;
ShaderProgram* prog = new ShaderProgram(*this);
Array<String> args = getVertexShaderAttributesCode((EVertexFormat)params.vs.format);
Array<ConstString> arr;
foreach(it, args)
arr.push(it->toConst());
prog->init(*vs, *ps, arr.constRange());
it->val->init(prog);
return *it->val;
}