void Model::CreatePipelineState()
{
Microsoft::WRL::ComPtr<ID3DBlob> VertexShader;
Microsoft::WRL::ComPtr<ID3DBlob> PixelShader;
LoadAndCompileShader(VertexShader, PixelShader);
std::array<D3D12_INPUT_ELEMENT_DESC, 2> InputElementDesc
{ {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
} };
D3D12_GRAPHICS_PIPELINE_STATE_DESC PipelineStateDesc = {};
PipelineStateDesc.InputLayout = { InputElementDesc.data(), static_cast<UINT>(InputElementDesc.size()) };
PipelineStateDesc.pRootSignature = RootSignature.Get();
PipelineStateDesc.VS = CD3DX12_SHADER_BYTECODE(VertexShader.Get());
PipelineStateDesc.PS = CD3DX12_SHADER_BYTECODE(PixelShader.Get());
PipelineStateDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
PipelineStateDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
PipelineStateDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
PipelineStateDesc.SampleMask = UINT_MAX;
PipelineStateDesc.SampleDesc.Count = 1;
PipelineStateDesc.NumRenderTargets = 1;
PipelineStateDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
PipelineStateDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
PipelineStateDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
Utility::ThrowOnFail(DeviceContext.GetDevice()->CreateGraphicsPipelineState(&PipelineStateDesc, IID_PPV_ARGS(&PipelineState)));
}
HRESULT IDX8PixelVertexShaderImp::Initialize(MNMesh *mnmesh, INode *node)
{
if(map->GetInitVS())
{
HRESULT hr = LoadAndCompileShader();
if(FAILED(hr))
return hr;
map->SetInitVS(false);
}
if(stdDualVS)
return stdDualVS->Initialize(mnmesh, node);
else
return E_FAIL;
}
static void
SetupShaders(void)
{
/* emit same color to both draw buffers */
static const char *fragShaderText =
"void main() {\n"
" gl_FragData[0] = gl_Color; \n"
" gl_FragData[1] = gl_Color; \n"
"}\n";
GLuint fragShader;
fragShader = LoadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
Program = glCreateProgram();
glAttachShader(Program, fragShader);
glLinkProgram(Program);
CheckLink(Program);
glUseProgram(Program);
}
/**
* Read a shader from a file.
*/
static void
ReadShader(GLuint shader, const char *filename)
{
const int max = 100*1000;
int n;
char *buffer = (char*) malloc(max);
FILE *f = fopen(filename, "r");
if (!f) {
fprintf(stderr, "brick: Unable to open shader file %s\n", filename);
exit(1);
}
n = fread(buffer, 1, max, f);
printf("brick: read %d bytes from shader file %s\n", n, filename);
if (n > 0) {
buffer[n] = 0;
LoadAndCompileShader(shader, buffer);
}
fclose(f);
free(buffer);
}
static void
Init(void)
{
static const char *fragShaderText =
"uniform vec4 diffuse;\n"
"uniform vec4 specular;\n"
"varying vec3 normal;\n"
"void main() {\n"
" // Compute dot product of light direction and normal vector\n"
" float dotProd = max(dot(gl_LightSource[0].position.xyz, \n"
" normalize(normal)), 0.0);\n"
" // Compute diffuse and specular contributions\n"
" gl_FragColor = diffuse * dotProd + specular * pow(dotProd, 20.0);\n"
"}\n";
static const char *vertShaderText =
"varying vec3 normal;\n"
"void main() {\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
" normal = gl_NormalMatrix * gl_Normal;\n"
"}\n";
const char *version;
version = (const char *) glGetString(GL_VERSION);
if (version[0] != '2' || version[1] != '.') {
printf("This program requires OpenGL 2.x, found %s\n", version);
exit(1);
}
GetExtensionFuncs();
fragShader = glCreateShader_func(GL_FRAGMENT_SHADER);
if (FragProgFile)
ReadShader(fragShader, FragProgFile);
else
LoadAndCompileShader(fragShader, fragShaderText);
vertShader = glCreateShader_func(GL_VERTEX_SHADER);
if (VertProgFile)
ReadShader(vertShader, VertProgFile);
else
LoadAndCompileShader(vertShader, vertShaderText);
program = glCreateProgram_func();
glAttachShader_func(program, fragShader);
glAttachShader_func(program, vertShader);
glLinkProgram_func(program);
CheckLink(program);
glUseProgram_func(program);
uDiffuse = glGetUniformLocation_func(program, "diffuse");
uSpecular = glGetUniformLocation_func(program, "specular");
uTexture = glGetUniformLocation_func(program, "texture");
printf("DiffusePos %d SpecularPos %d TexturePos %d\n",
uDiffuse, uSpecular, uTexture);
glUniform4fv_func(uDiffuse, 1, diffuse);
glUniform4fv_func(uSpecular, 1, specular);
/* assert(glGetError() == 0);*/
glUniform1i_func(uTexture, 2); /* use texture unit 2 */
/*assert(glGetError() == 0);*/
if (CoordAttrib) {
int i;
glBindAttribLocation_func(program, CoordAttrib, "coord");
i = glGetAttribLocation_func(program, "coord");
assert(i >= 0);
if (i != CoordAttrib) {
printf("Hmmm, NVIDIA bug?\n");
CoordAttrib = i;
}
else {
printf("Mesa bind attrib: coord = %d\n", i);
}
}
/*assert(glGetError() == 0);*/
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0f);
MakeSphere();
MakeRect();
CurList = SphereList;
#if TEXTURE
MakeTexture();
#endif
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
printf("Press p to toggle between per-pixel and per-vertex lighting\n");
/* test glGetShaderSource() */
if (0) {
GLsizei len = strlen(fragShaderText) + 1;
GLsizei lenOut;
GLchar *src =(GLchar *) malloc(len * sizeof(GLchar));
glGetShaderSource_func(fragShader, 0, NULL, src);
glGetShaderSource_func(fragShader, len, &lenOut, src);
assert(len == lenOut + 1);
assert(strcmp(src, fragShaderText) == 0);
free(src);
}
assert(glIsProgram_func(program));
assert(glIsShader_func(fragShader));
assert(glIsShader_func(vertShader));
glColor3f(1, 0, 0);
/* for testing state vars */
{
static GLfloat fc[4] = { 1, 1, 0, 0 };
static GLfloat amb[4] = { 1, 0, 1, 0 };
glFogfv(GL_FOG_COLOR, fc);
glLightfv(GL_LIGHT1, GL_AMBIENT, amb);
}
#if 0
TestFunctions();
#else
(void) TestFunctions;
#endif
}
static void
Init(void)
{
static const char *fragShaderText =
"uniform sampler2DShadow shadowTex2D; \n"
"uniform sampler2DRectShadow shadowTexRect; \n"
"void main() {\n"
#if USE_RECT
" gl_FragColor = shadow2DRectProj(shadowTexRect, gl_TexCoord[0]); \n"
#else
" gl_FragColor = shadow2D(shadowTex2D, gl_TexCoord[0].xyz); \n"
#endif
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
" gl_TexCoord[0] = gl_MultiTexCoord0; \n"
"}\n";
const char *version;
#if USE_RECT
if (!glutExtensionSupported("GL_ARB_texture_rectangle")) {
printf("This program requires GL_ARB_texture_rectangle\n");
exit(1);
}
#endif
version = (const char *) glGetString(GL_VERSION);
if (version[0] != '2' || version[1] != '.') {
printf("This program requires OpenGL 2.x, found %s\n", version);
exit(1);
}
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
if (FragProgFile)
ReadShader(fragShader, FragProgFile);
else
LoadAndCompileShader(fragShader, fragShaderText);
vertShader = glCreateShader(GL_VERTEX_SHADER);
if (VertProgFile)
ReadShader(vertShader, VertProgFile);
else
LoadAndCompileShader(vertShader, vertShaderText);
program = glCreateProgram();
glAttachShader(program, fragShader);
glAttachShader(program, vertShader);
glLinkProgram(program);
CheckLink(program);
glUseProgram(program);
uTexture2D = glGetUniformLocation(program, "shadowTex2D");
uTextureRect = glGetUniformLocation(program, "shadowTexRect");
printf("uTexture2D %d uTextureRect %d\n", uTexture2D, uTextureRect);
if (uTexture2D >= 0) {
glUniform1i(uTexture2D, 0); /* use texture unit 0 */
}
if (uTextureRect >= 0) {
glUniform1i(uTextureRect, 1); /* use texture unit 0 */
}
CheckError(__LINE__);
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
glColor3f(1, 1, 1);
MakeTexture();
CheckError(__LINE__);
}
static void
Init(void)
{
const char *version;
GLint i;
version = (const char *) glGetString(GL_VERSION);
if (version[0] != '2' || version[1] != '.') {
printf("Warning: this program expects OpenGL 2.0\n");
/*exit(1);*/
}
GetExtensionFuncs();
vertShader = glCreateShader_func(GL_VERTEX_SHADER);
LoadAndCompileShader(vertShader, VertShaderText);
fragShader = glCreateShader_func(GL_FRAGMENT_SHADER);
LoadAndCompileShader(fragShader, FragShaderText);
program = glCreateProgram_func();
glAttachShader_func(program, fragShader);
glAttachShader_func(program, vertShader);
glLinkProgram_func(program);
CheckLink(program);
glUseProgram_func(program);
for (i = 0; Uniforms[i].name; i++) {
Uniforms[i].location
= glGetUniformLocation_func(program, Uniforms[i].name);
printf("Uniform %s location: %d\n", Uniforms[i].name,
Uniforms[i].location);
switch (Uniforms[i].size) {
case 1:
glUniform1fv_func(Uniforms[i].location, 1, Uniforms[i].value);
break;
case 2:
glUniform2fv_func(Uniforms[i].location, 1, Uniforms[i].value);
break;
case 3:
glUniform3fv_func(Uniforms[i].location, 1, Uniforms[i].value);
break;
case 4:
glUniform4fv_func(Uniforms[i].location, 1, Uniforms[i].value);
break;
default:
abort();
}
}
assert(glGetError() == 0);
glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram_func(program));
assert(glIsShader_func(fragShader));
assert(glIsShader_func(vertShader));
glColor3f(1, 0, 0);
}
const string ShaderPreCompiler::LoadAndCompileShader( const string& current_file, string const* current_dir )
{
string path;
if(!current_dir)
path = SolvePath(current_file);
else
path = *current_dir+"\\"+current_file;
File f(path);
if(shader_map.find(path) != shader_map.end())
return shader_map[path];
ifstream stream(path);
std::stringstream buffer;
char cbuffer = 0;
std::string _path = f.Path();
try
{
while (stream.read(&cbuffer,1) > 0)
{
std::string instruction = "";
std::string value = "";
switch(cbuffer)
{
case '#':
while(stream.read(&cbuffer,1) > 0 && cbuffer != ' ')
instruction += cbuffer;
while(stream.read(&cbuffer,1) > 0 && cbuffer != '\n')
value += cbuffer;
value += '\n';
switch(preprocessor(instruction))
{
case PREPROCESSOR_INCLUDE:
if(value.find_first_of('"') != std::string::npos)
buffer << LoadAndCompileShader(value.substr(value.find_first_of('"')+1, value.find_last_of('"')-1),&_path);
else if(value.find_first_of('<') != std::string::npos)
buffer << LoadAndCompileShader(value.substr(value.find_first_of('<')+1, value.find_last_of('>')-1),NULL);
break;
default:
buffer << "#" << instruction << " " << value << "\n";
break;
}
break;
case '\n':
buffer << cbuffer;
break;
case ' ':
case '\t':
case '\r':
continue;
default:
buffer << cbuffer;
while(stream.read(&cbuffer,1) > 0 && cbuffer != '\n')
buffer <<cbuffer;
buffer << '\n';
break;
}
}
}
catch (std::exception e)
{
printf("ex %s",e.what());
}
return buffer.str();
}
bool CRenderer::InitShader()
{
int glerr = 0;
int islinked = GL_FALSE;
fprintf(stderr, "Compiling vertex shader...\n");
m_vshader = LoadAndCompileShader(GL_VERTEX_SHADER, CLynx::GetBaseDirFX() + "vshader.txt");
if(m_vshader < 1)
return false;
fprintf(stderr, "Compiling fragment shader...\n");
m_fshader = LoadAndCompileShader(GL_FRAGMENT_SHADER, CLynx::GetBaseDirFX() + "fshader.txt");
if(m_fshader < 1)
return false;
m_program = glCreateProgram();
glAttachShader(m_program, m_vshader);
if((glerr = glGetError()) != 0)
{
fprintf(stderr, "Failed to attach vertex shader\n");
return false;
}
glAttachShader(m_program, m_fshader);
if((glerr = glGetError()) != 0)
{
fprintf(stderr, "Failed to attach fragment shader\n");
return false;
}
glLinkProgram(m_program);
glGetProgramiv(m_program, GL_LINK_STATUS, &islinked);
if(islinked != GL_TRUE || (glerr = glGetError()) != 0)
{
char logbuffer[1024];
int usedlogbuffer;
glGetProgramInfoLog(m_program, sizeof(logbuffer), &usedlogbuffer, logbuffer);
fprintf(stderr, "GL Program Link Error:\n%s\n", logbuffer);
return false;
}
glUseProgram(m_program);
if((glerr = glGetError()) != 0)
{
if(glerr == GL_INVALID_VALUE)
fprintf(stderr, "%s\n", "Error: No Shader program");
else if(glerr == GL_INVALID_OPERATION)
fprintf(stderr, "%s\n", "Error: invalid operation");
else
fprintf(stderr, "Failed to use program %i\n", glerr);
return false;
}
m_shadowMapUniform = glGetUniformLocation(m_program, "ShadowMap");
m_tex = glGetUniformLocation(m_program, "tex");
m_lightmap = glGetUniformLocation(m_program, "lightmap");
m_uselightmap = glGetUniformLocation(m_program, "uselightmap");
m_normalMap = glGetUniformLocation(m_program, "normalMap");
glUniform1i(m_tex, 0); // diffuse texture to channel 0
glUniform1i(m_normalMap, 1); // tangent space normal map in channel 1
glUniform1i(m_lightmap, 2); // pre-baked shadows to channel 2
glUniform1i(m_shadowMapUniform, 7); // shadow space matrix to channel 7
glUniform1i(m_uselightmap, 0);
glUseProgram(0);
int isValid;
glValidateProgram(m_program);
glGetProgramiv(m_program, GL_VALIDATE_STATUS, &isValid);
if(isValid != GL_TRUE)
{
char logbuffer[1024];
int usedlogbuffer;
glGetProgramInfoLog(m_program, sizeof(logbuffer), &usedlogbuffer, logbuffer);
fprintf(stderr, "GL Program Error:\n%s\n", logbuffer);
return false;
}
return true;
}
