TiledLightRenderer::TiledLightRenderer(DeferredRenderer& deferred, bool hdr) : LightContextRenderer(deferred)
{
_tileCount = deferred.resolution() / TILE_SIZE;
if(deferred.resolution().x() % TILE_SIZE.x() != 0)
_tileCount.x()++;
if(deferred.resolution().y() % TILE_SIZE.y() != 0)
_tileCount.y()++;
ShaderCompiler shader(ShaderCompiler::COMPUTE_SHADER);
shader.setSource(StringUtils::readFile("shader/tiledLightShader.cs"));
auto optShader = Shader::linkComputeShader(shader.compile({}));
if(!optShader.hasValue())
{
LOG("shader/tiledLightShader.cs error:\n", shader.error());
LOG("Link erorr:", Shader::lastLinkError());
}
else
_computeShader = optShader.value();
_computeShader->bind();
_nbLightUniformId = _computeShader->uniformLocation("nbLight");
Texture::GenTexParam param;
param.format = Texture::RGB16;
param.nbLevels = 1;
param.size = uivec3(256,256,1);
float* dat = new float[256*256*3];
std::ifstream inDat("shader/brdf_256.dat", std::ios_base::binary);
inDat.read((char*)dat, sizeof(float)*256*256*3);
_processedBrdf = Texture::genTexture2D(param, dat, 3);
delete[] dat;
}
bool DATImageFileType::read( Image *image,
const Char8 *fileName)
{
bool retCode = false;
std::ifstream inDat(fileName), inVolS;
std::istream *inVol;
std::string keyStr, objectFileName;
const UInt32 lineBufferSize = 1024;
Char8 *value, *keySepPos, lineBuffer[lineBufferSize];
const Char8 keySep = ':';
int fileOffset, keyL, valueL;
std::map<std::string, KeyType>::iterator keyI;
std::map<std::string, FormatDesc>::iterator formatI;
KeyType key;
Image::Type formatType;
UInt32 channel = 1;
UInt32 res[3];
UInt32 dataSize = 0;
Image::PixelFormat pixelFormat = Image::OSG_L_PF;
char *dataBuffer = 0;
bool needConversion = false;
// default endian type is big endian
bool big_endian = true;
res[0] = res[1] = res[2] = 0;
fileOffset = 0;
formatType = Image::OSG_INVALID_IMAGEDATATYPE;
dataSize = 0;
dataBuffer = 0;
initTypeMap();
// read the data file
for(lineBuffer[0] = 0;
inDat.getline(lineBuffer, lineBufferSize);
lineBuffer[0] = 0)
{
if((keySepPos = strchr(lineBuffer,keySep)))
{
keyL = keySepPos - lineBuffer;
keyStr.assign( lineBuffer, keyL );
keyI = _keyStrMap.find(keyStr);
key = ((keyI == _keyStrMap.end()) ? UNKNOWN_KT : keyI->second);
value = keySepPos + 1;
while (value && isspace(*value))
value++;
valueL = int(strlen(value));
while (isspace(value[valueL-1]))
value[--valueL] = 0;
switch (key)
{
case OBJECT_FILE_NAME_KT:
objectFileName = value;
image->setAttachmentField ( keyStr, value );
break;
case CHANNEL_KT:
sscanf ( value, "%u", &(channel) );
image->setAttachmentField ( keyStr, value );
break;
case RESOLUTION_KT:
sscanf ( value, "%u %u %u",
&(res[0]), &(res[1]), &(res[2]));
image->setAttachmentField ( keyStr, value );
break;
case FORMAT_KT:
formatI = _formatStrMap.find(value);
if (formatI != _formatStrMap.end())
{
formatType = formatI->second.type;
}
else
{
formatType = Image::OSG_INVALID_IMAGEDATATYPE;
}
image->setAttachmentField ( keyStr, value );
break;
case ENDIAN_KT:
if(!strcmp(value, "LITTLE"))
big_endian = false;
image->setAttachmentField ( keyStr, value );
break;
case FILE_OFFSET_KT:
sscanf ( value, "%d", &fileOffset );
image->setAttachmentField ( keyStr, value );
break;
case UNKNOWN_KT:
FNOTICE (( "Uknown DAT file key: >%s<\n",
keyStr.c_str() ));
image->setAttachmentField ( keyStr, value );
break;
case SLICE_THICKNESS_KT:
default:
image->setAttachmentField ( keyStr, value );
break;
}
}
else
{
FINFO (("Skip DAT line\n"));
}
}
// set pixelformat
switch (channel)
{
case 4:
pixelFormat = Image::OSG_RGBA_PF;
break;
case 3:
pixelFormat = Image::OSG_RGB_PF;
break;
case 2:
pixelFormat = Image::OSG_LA_PF;
break;
default:
pixelFormat = Image::OSG_L_PF;
break;
}
// check the setting and read the raw vol data
if (objectFileName.empty() == false)
{
if((res[0] > 0) && (res[1] > 0) && (res[2] > 0))
{
if(formatType != Image::OSG_INVALID_IMAGEDATATYPE)
{
inVolS.open(objectFileName.c_str(),
std::ios::in | std::ios::binary);
if (inVolS.fail() && ImageFileHandler::the()->getPathHandler())
{
// Try to find the file in the search path
inVolS.clear(); // reset the error state
PathHandler *ph =
ImageFileHandler::the()->getPathHandler();
inVolS.open(ph->findFile(objectFileName.c_str()).c_str(),
std::ios::in | std::ios::binary );
}
if(inVolS.fail())
{
// Maybe compressed and name not changed?
std::string gzname = objectFileName + ".gz";
inVolS.clear(); // reset the error state
inVolS.open(gzname.c_str(),
std::ios::in | std::ios::binary );
if(inVolS.fail() &&
ImageFileHandler::the()->getPathHandler())
{
// Try to find the file in the search path
inVolS.clear(); // reset the error state
PathHandler *ph =
ImageFileHandler::the()->getPathHandler();
inVolS.open(ph->findFile(gzname.c_str()).c_str(),
std::ios::in | std::ios::binary );
}
}
if(inVolS.good())
{
#ifdef OSG_WITH_ZLIB
zip_istream *unzipper = NULL;
#endif
image->set(pixelFormat,
res[0], res[1], res[2],
1, 1, 0.0, 0,
formatType);
image->clear();
dataSize = image->getSize();
UInt32 fileDataSize = dataSize;
if(isGZip(inVolS))
{
#ifdef OSG_WITH_ZLIB
unzipper = new zip_istream(inVolS);
inVol = unzipper;
#else
SFATAL << "Compressed streams are not supported! "
<< "Configure with --enable-png "
<< "--with-png=DIR options." << std::endl;
#endif
}
else
{
inVol = &inVolS;
// get length of the stream.
inVol->seekg(0, std::ios::end);
UInt64 length = inVol->tellg();
inVol->seekg(0, std::ios::beg);
if(length < dataSize - fileOffset)
{
// correct dataSize.
fileDataSize = length;
FWARNING (( "RAW file length to small!\n" ));
}
else if(length > dataSize - fileOffset)
{
FWARNING (( "RAW file length to big!\n" ));
}
}
if(needConversion)
{
dataBuffer = new char [ dataSize ];
}
else
{
dataBuffer =
reinterpret_cast<char *>(image->editData());
}
if(fileOffset != 0)
inVol->ignore (fileOffset);
inVol->read ( dataBuffer, fileDataSize );
#ifdef OSG_WITH_ZLIB
if(unzipper != NULL)
delete unzipper;
#endif
}
else
{
FWARNING (( "Can not open %s image data\n",
objectFileName.c_str() ));
}
}
else
{
FWARNING (( "Invalid/Missing DAT Format\n" ));
}
}
else
{
FWARNING (( "Invalid/Missing DAT Resolution\n" ));
}
}
else
{
FWARNING (( "Invalid/Missing DAT ObjectFileName\n" ));
}
// check/reformat vol data
if (dataSize && dataBuffer)
{
// check host endian type
UInt16 word = 0x0001;
UInt8 *byte = reinterpret_cast<UInt8 *>(&word);
bool host_big_endian = byte[0] ? false : true;
if(big_endian != host_big_endian)
image->swapDataEndian();
if (needConversion)
{
FLOG (("DAT-Data convert not impl. yet !\n"));
{
switch (formatType)
{
case Image::OSG_UINT8_IMAGEDATA:
break;
case Image::OSG_UINT16_IMAGEDATA:
break;
case Image::OSG_UINT32_IMAGEDATA:
break;
case Image::OSG_FLOAT32_IMAGEDATA:
break;
default:
;
}
}
}
else
{
retCode = true;
}
}
/* TODO
std::ifstream in(fileName);
Head head;
void *headData = (void*)(&head);
unsigned dataSize, headSize = sizeof(Head);
if ( in &&
in.read(static_cast<char *>(headData),
headSize) && head.netToHost() &&
image.set ( Image::PixelFormat(head.pixelFormat),
head.width, head.height, head.depth, head.mipmapCount,
head.frameCount, float(head.frameDelay) / 1000.0) &&
(dataSize = image.getSize()) &&
in.read((char *)(image.getData()), dataSize ))
retCode = true;
else
retCode = false;
*/
return retCode;
}
