/* Load vertex and fragment shader and return the compiled program */
GLuint GLWrapper::LoadShader(const char *vertex_path, const char *fragment_path)
{
GLuint vertShader, fragShader;
// Read shaders
std::string vertShaderStr = readFile(vertex_path);
std::string fragShaderStr = readFile(fragment_path);
GLint result = GL_FALSE;
int logLength;
vertShader = BuildShader(GL_VERTEX_SHADER, vertShaderStr);
fragShader = BuildShader(GL_FRAGMENT_SHADER, fragShaderStr);
std::cout << "Linking program" << std::endl;
GLuint program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &result);
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
std::vector<char> programError((logLength > 1) ? logLength : 1);
glGetProgramInfoLog(program, logLength, NULL, &programError[0]);
std::cout << &programError[0] << std::endl;
glDeleteShader(vertShader);
glDeleteShader(fragShader);
return program;
}
void init()
{
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
const float vertexPositions[] = {
0.75f, 0.75f, 0.0f, 1.0f,
0.75f, -0.75f, 0.0f, 1.0f,
-0.75f, -0.75f, 0.0f, 1.0f,
};
glGenBuffers(1, &positionBufferObject);
glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
const std::string vertexShader(
"#version 330\n"
"layout(location = 0) in vec4 position;\n"
"void main()\n"
"{\n"
" gl_Position = position;\n"
"}\n"
);
const std::string fragmentShader(
"#version 330\n"
"out vec4 outputColor;\n"
"void main()\n"
"{\n"
" outputColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n"
"}\n"
);
GLuint vertShader = BuildShader(GL_VERTEX_SHADER, vertexShader);
GLuint fragShader = BuildShader(GL_FRAGMENT_SHADER, fragmentShader);
program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
GLint status;
glGetProgramiv (program, GL_LINK_STATUS, &status);
if (status == GL_FALSE)
{
if(!glext_ARB_debug_output)
{
GLint infoLogLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *strInfoLog = new GLchar[infoLogLength + 1];
glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
fprintf(stderr, "Linker failure: %s\n", strInfoLog);
delete[] strInfoLog;
}
throw std::runtime_error("Shader could not be linked.");
}
}
GLuint RenderingEngine2::BuildProgram(const char* vertexShaderSource,
const char* fragmentShaderSource) const
{
GLuint vertexShader = BuildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = BuildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
char messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
#ifdef __APPLE__
printf("ERROR: %s",messages);
#endif
#ifdef ANDROID_NDK
LOGI("ERROR: %s",messages);
#endif
}
return programHandle;
}
void RenderingEngine::BuildProgram(const char* vertexShaderSource,
const char* fragmentShaderSource,
ProgramHandles& program) const
{
GLuint vertexShader = BuildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = BuildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
std::cout << messages;
exit(1);
}
program.Program = programHandle;
AttributeHandles& attribs = program.Attributes;
attribs.Position = glGetAttribLocation(programHandle, "Position");
attribs.Normal = glGetAttribLocation(programHandle, "Normal");
attribs.TexCoord = glGetAttribLocation(programHandle, "TextureCoordIn");
UniformHandles& uniforms = program.Uniforms;
uniforms.Projection = glGetUniformLocation(programHandle, "Projection");
uniforms.Modelview = glGetUniformLocation(programHandle, "Modelview");
uniforms.Sampler = glGetUniformLocation(programHandle, "Sampler");
uniforms.Model = glGetUniformLocation(programHandle, "Model");
uniforms.EyePosition = glGetUniformLocation(programHandle, "EyePosition");
}
//------------------------------------------------------------------------------
int32 CGUIShader_opengl_base::LoadAndCompile(const CGUIString& rVertexShaderFileName, const CGUIString& rFragmentShaderFileName)
{
#if defined(GUIEX_RENDER_OPENGL) || defined(GUIEX_RENDER_OPENGL_ES2)
DestroyShader();
//create shader
m_uVertexShader = BuildShader(rVertexShaderFileName, GL_VERTEX_SHADER);
m_uFragmentShader = BuildShader(rFragmentShaderFileName, GL_FRAGMENT_SHADER);
m_uProgramId = glCreateProgram();
glAttachShader(m_uProgramId, m_uVertexShader);
glAttachShader(m_uProgramId, m_uFragmentShader);
glLinkProgram(m_uProgramId);
GLint linkSuccess;
glGetProgramiv(m_uProgramId, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE)
{
char messages[256];
glGetProgramInfoLog(m_uProgramId, sizeof(messages), 0, &messages[0]);
GUI_THROW( GUI_FORMAT( "[CGUIShader_opengl_base::LoadAndCompile]: %s", messages ));
return -1;
}
CacheAttributeLoc();
CacheUniformLoc();
#endif //#if defined(GUIEX_RENDER_OPENGL) || defined(GUIEX_RENDER_OPENGL_ES2)
return 0;
}
GLuint BuildProgram(const char* vsKey, const char* fsKey) {
std::cout << "Compiling " << vsKey << "..." << std::endl;;
const char* vsString = glswGetShader(vsKey);
// PezCheckCondition(vsString, glswGetError());
GLuint vsHandle = BuildShader(vsString, GL_VERTEX_SHADER);
std::cout << "Compiling " << fsKey << "..." << std::endl;
const char* fsString = glswGetShader(fsKey);
// PezCheckCondition(fsString, glswGetError());
GLuint fsHandle = BuildShader(fsString, GL_FRAGMENT_SHADER);
std::cout << "Linking..." << std::endl;
GLint linkSuccess;
GLchar messages[256];
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vsHandle);
glAttachShader(programHandle, fsHandle);
glBindAttribLocation(programHandle, SlotPosition, "Position");
glBindAttribLocation(programHandle, SlotNormal, "Normal");
glLinkProgram(programHandle);
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
// PezCheckCondition(linkSuccess, messages);
return programHandle;
}
AsShaderBuild AsShader::LoadShaderFromFile(std::string* pShaderPath, GLuint pNumFiles, GLenum pType)
{
const char* tmpText = (const char*)"";
AsShaderBuild log;
log.mSuccess = GL_TRUE;
for (GLuint it = 0; it < pNumFiles; it++)
{
unsigned char* text;
std::ifstream file;
file.open(pShaderPath[it].c_str(), ios::in); // opens as ASCII!
if (!file) log.mSuccess = GL_FALSE;
file.seekg(0, file.end);
int len = file.tellg();
if (len == 0) log.mSuccess = GL_FALSE; // Error: Empty File
text = (GLubyte*) new char[len+1];
if (*text == 0) log.mSuccess = GL_FALSE; // can't reserve memory
// len isn't always strlen cause some characters are stripped in ascii read...
// it is important to 0-terminate the real length later, len is just max possible value...
text[len] = 0;
GLuint i=0;
while (file.good())
{
text[i] = file.get(); // get character from file.
if (!file.eof())
i++;
}
text[i] = 0; // 0-terminate it at the correct position
file.close();
//now take the buffer and put it in the shader text
tmpText += '\n';
for(int ix = 0; ix < len; i++)
{
tmpText += text[ix];
}
delete[] text;
}
//now compile the shader
if (log.mSuccess = GL_TRUE)
{
log = BuildShader(&tmpText, pType);
}
return log;
}
static GLuint BuildProgram(const char* vsKey, const char* fsKey)
{
DebugString("Compiling '%s'...\n", vsKey);
const char* vsString = glswGetShader(vsKey);
if (!vsString)
{
FatalError("%s\n", glswGetError());
}
GLuint vsHandle = BuildShader(vsString, GL_VERTEX_SHADER);
DebugString("Compiling '%s'...\n", fsKey);
const char* fsString = glswGetShader(fsKey);
if (!fsString)
{
FatalError("%s\n", glswGetError());
}
GLuint fsHandle = BuildShader(fsString, GL_FRAGMENT_SHADER);
DebugString("Linking...\n");
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vsHandle);
glAttachShader(programHandle, fsHandle);
glBindAttribLocation(programHandle, VertexAttributes::Position, "Position");
glBindAttribLocation(programHandle, VertexAttributes::Normal, "Normal");
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE)
{
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
FatalError(messages);
}
else
{
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
DebugString(messages);
}
return programHandle;
}
/* Load vertex and fragment shader and return the compiled program */
GLuint GLWrapper::BuildShaderProgram(std::string vertShaderStr, std::string fragShaderStr)
{
GLuint vertShader, fragShader;
GLint result = GL_FALSE;
try
{
vertShader = BuildShader(GL_VERTEX_SHADER, vertShaderStr);
fragShader = BuildShader(GL_FRAGMENT_SHADER, fragShaderStr);
}
catch (std::exception &e)
{
throw std::exception("BuildShaderProgram() Build shader failure. Abandoning");
}
GLuint program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
GLint status;
glGetProgramiv(program, GL_LINK_STATUS, &status);
if (status == GL_FALSE)
{
GLint infoLogLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *strInfoLog = new GLchar[infoLogLength + 1];
glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
std::cerr << "Linker error: " << strInfoLog << std::endl;
delete[] strInfoLog;
throw std::runtime_error("Shader could not be linked.");
}
glDeleteShader(vertShader);
glDeleteShader(fragShader);
return program;
}
GLuint BuildProgram(const char *vShader,const char *fShader) const
{
GLuint vertexShader=BuildShader(vShader,GL_VERTEX_SHADER);
GLuint fragmentShader=BuildShader(fShader,GL_FRAGMENT_SHADER);
GLuint programHandle=glCreateProgram();
glAttachShader(programHandle,vertexShader);
glAttachShader(programHandle,fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle,GL_LINK_STATUS,&linkSuccess);
if(linkSuccess==GL_FALSE)
{
GLchar messages[256];
glGetProgramInfoLog(programHandle,sizeof(messages),0,&messages[0]);
printf("compile glsl error : %s\n",messages);
}
return programHandle;
}
GLuint BuildProgram(const char *vertexShaderSource,
const char *fragmentShaderSource) {
GLuint vertexShader = BuildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = BuildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
std::cout << messages;
exit(1);
}
return programHandle;
}
NzSkyboxBackground::NzSkyboxBackground()
{
if (!s_indexBuffer)
s_indexBuffer = BuildIndexBuffer();
if (!s_shader)
s_shader = BuildShader();
if (!s_vertexBuffer)
s_vertexBuffer = BuildVertexBuffer();
m_indexBuffer = s_indexBuffer;
m_sampler.SetWrapMode(nzSamplerWrap_Clamp); // Nécessaire pour ne pas voir les côtés
m_shader = s_shader;
m_vertexBuffer = s_vertexBuffer;
}
bool TextureDemo::Init()
{
if (!D3DApp::Init())
{
return false;
}
BuildGeometries();
BuildShader();
BuildInputLayout();
LoadTexture();
return true;
}
bool BaseApp::Init( HWND hWnd )
{
DeviceDx11& refDevice = DeviceDx11::GetInstance();
if( !refDevice.InitDevice( hWnd ) )
{
return false;
}
if( !SetUpDxResource( &refDevice ) )
{
return false;
}
if( !BuildShader( &refDevice ) )
{
return false;
}
m_pObject = new Object();
m_pObject->Init();
if( !CreateVertexBuffer() )
{
return false;
}
if( !CreateIndexBuffer() )
{
return false;
}
if( !CreateConstantBuffer() )
{
return false;
}
return true;
}
bool CRhGLShaderProgram::BuildProgram(const GLchar* VertexShader, const GLchar* FragmentShader)
{
// Shaders MUST consist of both a vertex AND a fragment shader in 2.0...
if ( (VertexShader == NULL) || (FragmentShader == NULL) )
return false;
PreBuild();
GLuint hVsh = BuildShader( VertexShader, GL_VERTEX_SHADER );
GLuint hFsh = BuildShader( FragmentShader, GL_FRAGMENT_SHADER );
if ( (hVsh == 0) || (hFsh == 0) )
return false;
m_hProgram = glCreateProgram();
if ( m_hProgram == 0 )
return false;
glAttachShader( m_hProgram, hVsh );
glAttachShader( m_hProgram, hFsh );
// These bindings are forced here so that mesh drawing can enable the
// appropriate vertex array based on the same binding values.
// Note: These must be done before we attempt to link the program...
// Note2: Rhino supports multiple textures but for now we'll only
// provide for a single set of texture coordinates.
glBindAttribLocation( m_hProgram, ATTRIB_VERTEX, "rglVertex" );
glBindAttribLocation( m_hProgram, ATTRIB_NORMAL, "rglNormal" );
glBindAttribLocation( m_hProgram, ATTRIB_TEXCOORD0, "rglTexCoord0" );
glBindAttribLocation( m_hProgram, ATTRIB_COLOR, "rglColor" );
glLinkProgram( m_hProgram );
GLint Success;
glGetProgramiv( m_hProgram, GL_LINK_STATUS, &Success );
if ( Success == GL_FALSE )
{
#if defined(_DEBUG)
GLint logLength;
glGetProgramiv( m_hProgram, GL_INFO_LOG_LENGTH, &logLength );
if (logLength > 0)
{
GLchar *log = (GLchar *)malloc(logLength);
glGetProgramInfoLog( m_hProgram, logLength, &logLength, log);
std::cout << "Program link log:\n" << log;
free(log);
}
#endif
glDetachShader( m_hProgram, hVsh );
glDetachShader( m_hProgram, hFsh );
glDeleteProgram( m_hProgram );
m_hProgram = 0;
}
glDeleteShader( hVsh );
glDeleteShader( hFsh );
if ( m_hProgram == 0 )
return false;
PostBuild();
return true;
}
bool Init()
{
srand(0);
LOG::Initialize();
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
LOG::Message("Unable to initialize SDL.");
LOG::Message(SDL_GetError());
return false;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_WM_SetCaption("FractalDemo", "FractalDemo");
Reshape(screen_width, screen_height);
glewInit();
if (!GLEW_VERSION_3_0)
{
LOG::Message("Requires OpenGL 3.0 or later.");
return false;
}
LOG::Message("GL_VENDOR", (char*)glGetString(GL_VENDOR));
LOG::Message("GL_RENDERER", (char*)glGetString(GL_RENDERER));
LOG::Message("GL_VERSION", (char*)glGetString(GL_VERSION));
LOG::Message("GL_SHADING_LANGUAGE_VERSION", (char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
const char* shader_error = "";
if (!gluInitializeCompiler())
{
LOG::Message("Unable to initialize GLSL compiler.");
return false;
}
if (!BuildShader(&ShaderProgram, vert_filepath, frag_filepath, &shader_error))
{
LOG::Message(shader_error);
return false;
}
if (!BindUniforms(ShaderProgram, uniform_locations, num_of_uniforms))
{
LOG::Message("Could not bind uniforms.");
return false;
}
if (!BindAttributes(ShaderProgram, attribute_locations, num_of_attributes))
{
LOG::Message("Could not bind attributes.");
return false;
}
glGenBuffers(1, &array_buffer);
glBindBuffer(GL_ARRAY_BUFFER, array_buffer);
glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), plane_data, GL_STATIC_DRAW);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glEnableVertexAttribArray(0);
reset();
return true;
}
int SceneBuilder::BuildObjectLOD(const Fmatrix& parent, CEditableObject* E, int sector_num)
{
if (!E->m_objectFlags.is(CEditableObject::eoUsingLOD)) return -1;
xr_string lod_name = E->GetLODTextureName();
b_material mtl;
mtl.surfidx = (u16)BuildTexture (LEVEL_LODS_TEX_NAME);
mtl.shader = (u16)BuildShader (E->GetLODShaderName());
mtl.sector = (u16)sector_num;
mtl.shader_xrlc = -1;
if ((u16(-1)==mtl.surfidx)||(u16(-1)==mtl.shader)) return -2;
int mtl_idx = FindInMaterials(&mtl);
if (mtl_idx<0){
l_materials.push_back(mtl);
mtl_idx = l_materials.size()-1;
}
l_lods.push_back(e_b_lod());
e_b_lod& b = l_lods.back();
Fvector p[4];
Fvector2 t[4];
for (int frame=0; frame<LOD_SAMPLE_COUNT; frame++){
E->GetLODFrame(frame,p,t,&parent);
for (int k=0; k<4; k++){
b.lod.faces[frame].v[k].set(p[k]);
b.lod.faces[frame].t[k].set(t[k]);
}
}
b.lod.dwMaterial= mtl_idx;
b.lod_name = lod_name.c_str();
xr_string l_name= lod_name.c_str();
u32 w,h;
int age;
if (!ImageLib.LoadTextureData(l_name.c_str(),b.data,w,h,&age)){
Msg("!Can't find LOD texture: '%s'",l_name.c_str());
return -2;
}
/* if (age!=E->Version()){
Msg("!Invalid LOD texture version: '%s'",l_name.c_str());
return -2;
}*/
l_name += "_nm";
if (!ImageLib.LoadTextureData(l_name.c_str(),b.ndata,w,h,&age)){
Msg("!Can't find LOD texture: '%s'",l_name.c_str());
return -2;
}
/* if (age!=E->Version()){
Msg("!Invalid LOD texture version: '%s'",l_name.c_str());
return -2;
}*/
// b.data
/*
// make lod
Fbox bb = E->GetBox();
E->m_Flags.set (CEditableObject::eoUsingLOD,FALSE);
object_for_render = E;
ImageLib.CreateLODTexture (bb, b.data, LOD_IMAGE_SIZE,LOD_IMAGE_SIZE,LOD_SAMPLE_COUNT);
E->m_Flags.set (CEditableObject::eoUsingLOD,TRUE);
// build lod normals
b.ndata.resize (LOD_IMAGE_SIZE*LOD_IMAGE_SIZE*LOD_SAMPLE_COUNT);
U8Vec hemi_temp (LOD_IMAGE_SIZE*LOD_IMAGE_SIZE*LOD_SAMPLE_COUNT,0);
Fvector o_center,o_size;
Fmatrix M,Mi;
bb.getradius (o_size);
bb.getcenter (o_center);
SPBItem* PB = UI->ProgressStart(LOD_SAMPLE_COUNT*LOD_IMAGE_SIZE,lod_name.c_str());
float dW = _max(o_size.x,o_size.z)/(LOD_IMAGE_SIZE/2);
float dH = o_size.y/(LOD_IMAGE_SIZE/2);
float dR = bb.getradius();
float d2R = dR*2.f;
XRC.ray_options (CDB::OPT_CULL);
ETOOLS::ray_options (CDB::OPT_CULL);
float tN=0.f,tH=0.f,tT=0.f,tR=0.f;
float LOD_CALC_SAMPLES = Scene->m_LevelOp.m_LOD_Quality;
s32 LOD_CALC_SAMPLES_LIM= LOD_CALC_SAMPLES/2;
// preload textures
for (SurfaceIt surf_it=E->Surfaces().begin(); surf_it!=E->Surfaces().end(); surf_it++){
CSurface* surf = *surf_it;
Shader_xrLC* c_sh = EDevice.ShaderXRLC.Get(surf->_ShaderXRLCName());
if (!c_sh->flags.bRendering) continue;
if (0==surf->m_ImageData)surf->CreateImageData();
}
// preload CF Model
for (EditMeshIt mesh_it=E->Meshes().begin(); mesh_it!=E->Meshes().end(); mesh_it++)
(*mesh_it)->GenerateCFModel();
// calculate
for (u32 sample_idx=0; sample_idx<LOD_SAMPLE_COUNT; sample_idx++){
float angle = sample_idx*(PI_MUL_2/LOD_SAMPLE_COUNT);
M.setXYZ (0,angle,0);
M.translate_over (o_center);
Mi.invert (M);
for (s32 iH=0; iH<LOD_IMAGE_SIZE; iH++){
PB->Inc ();
float Y = (iH-(LOD_IMAGE_SIZE-1)/2)*dH;
for (s32 iW=0; iW<LOD_IMAGE_SIZE; iW++){
float X = (iW-LOD_IMAGE_SIZE/2)*dW;
u32 pixel = (LOD_IMAGE_SIZE-iH-1)*LOD_SAMPLE_COUNT*LOD_IMAGE_SIZE+LOD_IMAGE_SIZE*sample_idx+iW;
u32& tgt_n = b.ndata[pixel];
u8& tgt_h = hemi_temp[pixel];
u8 src_a = color_get_A (b.data[pixel]);
if (0==src_a) continue;
FvectorVec n_vec;
Fvector4Vec sample_pt_vec;//(iFloor(LOD_CALC_SAMPLES*LOD_CALC_SAMPLES));
//. FvectorVec c_vec;
Fvector start;
CTimer TT,TT1;
TT.Start();
SPickQuery PQ;
for (s32 iiH=-LOD_CALC_SAMPLES_LIM; iiH<=LOD_CALC_SAMPLES_LIM; iiH++){
float dY = iiH*(dH/LOD_CALC_SAMPLES);
for (s32 iiW=-LOD_CALC_SAMPLES_LIM; iiW<=LOD_CALC_SAMPLES_LIM; iiW++){
float dX= iiW*(dW/LOD_CALC_SAMPLES);
start.set (X+dX,Y+dY,0);
M.transform_tiny(start);
start.mad (M.k,-dR);
PQ.prepare_rq (start,M.k,d2R,CDB::OPT_CULL);
E->RayQuery (PQ);
if (PQ.r_count()){
PQ.r_sort();
Fvector N = {0,0,0};
for (s32 k=PQ.r_count()-1; k>=0; k--){
SPickQuery::SResult* R = PQ.r_begin()+k;
u32 uA;
if (!GetPointColor(R,uA)) continue;
float fA = float(uA)/255.f;
if (uA){
Fvector pt; pt.mad(PQ.m_Start,PQ.m_Direction,R->range-EPS_L);
Fvector4 ptt; ptt.set(pt.x,pt.y,pt.z,fA);
sample_pt_vec.push_back(ptt);
}
// normal
Fvector Nn;
Nn.mknormal (R->verts[0],R->verts[1],R->verts[2]);
Nn.mul (fA);
N.mul (1.f-fA);
N.add (Nn);
}
float n_mag = N.magnitude();
if (!fis_zero(n_mag,EPS))
n_vec.push_back (N.div(n_mag));
}
}
}
tN+=TT.Stop();
TT.Start();
// light points
float res_transp = 0.f;
for (Fvector4It pt_it=sample_pt_vec.begin(); pt_it!=sample_pt_vec.end(); pt_it++){
float avg_transp = 0.f;
for (BLIt it=simple_hemi.begin(); it!=simple_hemi.end(); it++){
TT1.Start();
Fvector start;
start.mad (Fvector().set(pt_it->x,pt_it->y,pt_it->z),it->light.direction,-dR);
PQ.prepare_rq (start,it->light.direction,dR,CDB::OPT_CULL);
E->RayQuery (PQ);
tR+=TT1.Stop();
float ray_transp= 1.f;
if (PQ.r_count()){
for (s32 k=0; k<PQ.r_count(); k++){
u32 a;
TT1.Start();
if (!GetPointColor(PQ.r_begin()+k,a)) continue;
tT+=TT1.Stop();
ray_transp *= (1.f - float(a)/255.f);
if (fis_zero(ray_transp,EPS_L)) break;
}
}
avg_transp += ray_transp;
}
avg_transp /= simple_hemi.size();
res_transp = res_transp*(1.f-pt_it->w)+avg_transp*pt_it->w;
}
tH+=TT.Stop();
tgt_h = iFloor (res_transp*255.f);
Fvector N={0,0,0};
if (!n_vec.empty()){
for (FvectorIt it=n_vec.begin(); it!=n_vec.end(); it++) N.add(*it);
N.div (n_vec.size());
N.normalize_safe();
Mi.transform_dir(N);
}
N.mul (0.5f);
N.add (0.5f);
N.mul (255.f);
tgt_n = color_rgba(iFloor(N.x),iFloor(N.y),iFloor(N.z),src_a);
}
}
}
Msg("Normal: %3.2fsec, Hemi: %3.2f, PC: %3.2f, RP: %3.2f",tN,tH,tT,tR);
ImageLib.ApplyBorders (b.ndata, LOD_IMAGE_SIZE*LOD_SAMPLE_COUNT,LOD_IMAGE_SIZE);
// fill alpha to N-channel
for (int px_idx=0; px_idx<int(b.ndata.size()); px_idx++)
b.ndata[px_idx] = subst_alpha(b.ndata[px_idx],hemi_temp[px_idx]);
UI->ProgressEnd(PB);
*/
return l_lods.size()-1;
}
AsShader::AsShader(const char** pShaderSource, GLenum pType): mShaderType(pType)
{
mShaderID = glCreateShader(mShaderType);
mBuildLog = BuildShader(pShaderSource, pType);
}
