| s's profileCodyBlog |  Tools  Help |
Cody |
July 22 List of publications of shadows@Comment Generated with XdkBib.
@Comment 51 article(s).
@InProceedings{ARHM00,
title = {Efficient image-based methods for rendering soft shadows},
author = {Agrawala, Maneesh and Ramamoorthi, Ravi and Heirich, Alan and Moll, Laurent},
year = {2000},
pages = {375--384},
id = {118},
booktitle = {Proceedings of SIGGRAPH '00},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@InProceedings{AA02,
title = {Approximate soft shadows on arbitrary surfaces using penumbra wedges},
author = {Assarson, Ulf and Akenine-M{\"o}ller, Tomas},
year = {2002},
pages = {297--306},
id = {119},
booktitle = {Rendering Techniques '02 (Proceedings of the 13th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Article{AA03,
title = {A Geometry-Based Soft Shadow Volume Algorithm Using Graphics Hardware},
author = {Assarson, Ulf and Akenine-M{\"o}ller, Tomas},
year = {2003},
id = {120},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2003)},
}
@InProceedings{ADMA03,
title = {An optimized soft shadow volume algorithm with real-time performance},
author = {Assarson, Ulf and Dougherty, Michael and Mounier, Michael and Akenine-M{\"o}ller, Tomas},
year = {2003},
id = {121},
booktitle = {Proceedings of the ACM SIGGRAPH/EUROGRAPHICS Workshop on Graphics Hardware},
publisher = {ACM Press},
}
@InProceedings{CC99,
title = {Real-Time Shadow Generation Using {BSP} Trees and Stencil Buffers},
author = {Costa Batagelo, Harlen and Costa, Junior, Ilaim},
year = {1999},
pages = {93--102},
id = {122},
booktitle = {Brazilian Symposium on Computer Graphics and Image Processing},
}
@InProceedings{BS01,
title = {Hardware-accelerated Rendering of Antialiased Shadows with Shadow Maps},
author = {Brabec, Stefan and Seidel, Hans-Peter},
year = {2001},
pages = {209--214},
id = {123},
booktitle = {Proceedings of Computer Graphics International '01},
publisher = {IEEE},
}
@InProceedings{BS02,
title = {Single Sample Soft Shadows using Depth Maps},
author = {Brabec, Stefan and Seidel, Hans-Peter},
year = {2002},
id = {124},
booktitle = {Proceedings of Graphics Interface},
}
@Article{BS03,
title = {Shadow Volumes on Programmable Graphics Hardware},
author = {Brabec, Stefan and Seidel, Hans-Peter},
year = {2003},
number = {3},
volume = {25},
id = {125},
journal = {Computer Graphics Forum (Proceedings of Eurographics '03)},
publisher = {Blackwell Publishers},
}
@InProceedings{CD03,
title = {Rendering Fake Soft Shadows with Smoothies},
author = {Chan, Eric and Durand, Fr\'edo},
year = {2003},
id = {126},
booktitle = {Proceedings of the EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Article{Crow77,
title = {Shadow algorithms for computer graphics},
author = {Crow, Franklin C.},
year = {1977},
pages = {242--248},
id = {127},
journal = {Computer Graphics (Proceedings of SIGGRAPH '77)},
publisher = {ACM SIGGRAPH},
}
@InProceedings{DF94,
title = {A fast shadow algorithm for area light sources using backprojection},
author = {Drettakis, George and Fiume, Eugene},
year = {1994},
pages = {223--230},
id = {128},
booktitle = {Proceedings of SIGGRAPH '94},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@InProceedings{FFB01,
title = {Adaptive shadow maps},
author = {Fernando, Randima and Fernandez, Sebastien and Bala, Kavita},
year = {2001},
pages = {387--390},
id = {129},
booktitle = {Proceedings of SIGGRAPH '01},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{GLLYSM03,
title = {Interactive Shadow Generation in Complex Environments},
author = {Govindaraju, Naga K. and Lloyd, Brandon and Lloyd, Brandon and Yoon, Sung-Eui and Sud, Avneesh and Manocha, Dinesh},
year = {2003},
id = {130},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2003)},
}
@Object{HH97,
title = {Simulating Soft Shadows with Graphics Hardware},
author = {Heckbert, S., Paul and Herf, Michael},
year = {1997},
institution = {Carnegie Mellon University},
number = {CMU-CS-97-104},
id = {131},
}
@Object{Herf97,
title = {Efficient Generation of Soft Shadow Textures},
author = {Herf, Michael},
year = {1997},
institution = {Carnegie Mellon University},
number = {CMU-CS-97-138},
id = {133},
}
@Article{HN85,
title = {Algorithms for antialiased cast shadows},
author = {Hourcade, J.-C. and Nicolas, A.},
year = {1985},
pages = {259--265},
id = {134},
journal = {Computer \& Graphics},
}
@InProceedings{KM99,
title = {Shadow Penumbras for Complex Objects by Depth-Dependent Filtering of Multi-Layer Depth Images},
author = {Keating, Brett and Max, Nelson},
year = {1999},
pages = {205--220},
id = {135},
booktitle = {Rendering Techniques '99 (Proceedings of the 10th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{KD03,
title = {Real-Time Soft Shadows Using a Single Light Sample},
author = {Kirsch, Florian and Doellner, Juergen},
year = {2003},
id = {136},
booktitle = {Proceedings of Winter School on Computer Graphics 2003},
}
@InProceedings{LV00,
title = {Deep Shadow Maps},
author = {Lokovic, Tom and Veach, Eric},
year = {2000},
pages = {385--392},
id = {137},
booktitle = {Proceedings of SIGGRAPH '00},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{Cool00,
title = {Shadow volume reconstruction from depth maps},
author = {Mc Cool, Michael D.},
year = {2000},
pages = {1--26},
id = {138},
journal = {ACM Transactions on Graphics},
}
@Article{RSC87,
title = {Rendering antialiased shadows with depth maps},
author = {Reeves, William T. and Salesin, David and Cook, Robert L.},
year = {1987},
pages = {283--291},
id = {139},
journal = {Computer Graphics (Proceedings of SIGGRAPH '87)},
publisher = {ACM SIGGRAPH},
}
@Article{SCH03,
title = {Shadow Silhouette Maps},
author = {Sen, Pradeep and Cammarano, Michael and Hanrahan, Pat},
year = {2003},
id = {140},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2003)},
}
@Article{SD02,
title = {Perspective shadow maps},
author = {Stamminger, Marc and Drettakis, George},
year = {2002},
pages = {557-562},
id = {141},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2002)},
}
@InProceedings{Zhang98,
title = {Forward Shadow Mapping},
author = {Zhang, Hansong},
year = {1998},
pages = {131--138},
id = {142},
booktitle = {Rendering Techniques '98 (Proceedings of the 9th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{WSP04,
title = {Light Space Perspective Shadow Maps},
author = {Wimmer, Michael and Scherzer, D. and Purgathofer, Werner},
year = {2004},
id = {143},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{MT04,
title = {Anti-aliasing and Continuity with Trapezoidal Shadow Maps},
author = {Martin, Tobias and Tan, Tiow-Seng},
year = {2004},
id = {144},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{CG04,
title = {A Lixel for every Pixel},
author = {Chong, Hamilton and Gortler, Steven J.},
year = {2004},
id = {145},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{Aila04,
title = {Alias-Free Shadow Maps},
author = {Aila, Timo},
year = {2004},
id = {146},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{LWGM04,
title = {CC Shadow Volumes},
author = {Lloyd, Brandon and Wendt, J. and Govindaraju, Naga K. and Manocha, Dinesh},
year = {2004},
id = {147},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{AA04,
title = {A Hierarchical Shadow Volume Algorithm},
author = {Aila, Timo and Akenine-M{\"o}ller, Tomas},
year = {2004},
id = {148},
booktitle = {Proceedings of the ACM SIGGRAPH/EUROGRAPHICS Workshop on Graphics Hardware},
publisher = {ACM Press},
}
@Article{AHT04,
title = {Approximate Soft Shadows with an Image-Space Flood-Fill Algorithm},
author = {Arvo, Jukka and Hirvikorpi, Mika and Tyystj{\"a}rvi, Joonas},
year = {2004},
pages = {271--280},
number = {3},
volume = {23},
id = {149},
journal = {Computer Graphics Forum (Proceedings of Eurographics '04)},
publisher = {Blackwell Publishers},
}
@InProceedings{Arvo04,
title = {Tiled Shadow Maps},
author = {Arvo, Jukka},
year = {2004},
id = {150},
booktitle = {Proceedings of Computer Graphics International '04},
publisher = {IEEE},
}
@Article{AA04b,
title = {Optimized Shadow Mapping Using the Stencil Buffer},
author = {Arvo, Jukka and Aila, Timo},
year = {2004},
id = {151},
journal = {Journal of Graphic Tools},
}
@InProceedings{AW04,
title = {Hardware Accelerated Soft-Shadows Using Penumbra Quads},
author = {Arvo, Jukka and Westerholm, Jan},
year = {2004},
pages = {11--18},
id = {152},
booktitle = {Proceedings of Winter School on Computer Graphics 2004},
}
@Article{TT97,
title = {Fast Analytic Shading and Shadowing for Area Light Sources},
author = {Takahashi, Tokiichiro and Tanaka, Toshimitsu},
year = {1997},
volume = {16},
number = {3},
id = {153},
journal = {Computer Graphics Forum (Proceedings of Eurographics '97)},
publisher = {Blackwell Publishers},
}
@Article{HLHS03,
title = {A survey of Real-Time Soft Shadows Algorithms},
author = {Hasenfratz, Jean-Marc and Lapierre, Marc and Holzschuh, Nicolas and Sillion, Fran\c{c}ois},
year = {2003},
number = {3},
volume = {22},
id = {154},
journal = {Computer Graphics Forum (Proceedings of Eurographics '03)},
publisher = {Blackwell Publishers},
}
@InProceedings{SPP05,
title = {Soft Shadows from Extended Light Sources
with Penumbra Deep Shadow Maps},
author = {St-Amour, Jean-Fran\c{c}ois and Poulin, Pierre and Paquette, Eric},
year = {2005},
pages = {105--112},
id = {157},
booktitle = {Proceedings of Graphics Interface},
}
@InProceedings{WH03,
title = {Penumbra Maps: Approximate Soft Shadows in Real-Time},
author = {Wyman, Chrys and Hansen, Charles},
year = {2003},
pages = {202-207},
id = {158},
booktitle = {Proceedings of the EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Article{William78,
title = {Casting Curved Shadows on Curved Surfaces},
author = {William, Lance},
year = {1978},
pages = {270 - 274},
id = {159},
journal = {Computer Graphics (Proceedings of SIGGRAPH '78)},
publisher = {ACM SIGGRAPH},
}
@Article{WPF90,
title = {A Survey of Shadow Algorithms},
author = {Woo, Andrew and Poulin, Pierre and Fournier, Alain},
year = {1990},
pages = {13-32},
id = {160},
journal = {IEEE Computer Graphics \& Applications},
}
@InProceedings{NM06,
title = {Splatting with shadows},
author = {Nulkar, Manjushree and Mueller, Klaus},
year = {2006},
pages = {35--50},
id = {161},
booktitle = {Proceedings of the 2006 International Workshop on Volume Graphics },
}
@InProceedings{SS98,
title = {Fast Calculation of Soft Shadow Textures Using Convolution},
author = {Soler, Cyril and Sillion, Fran\c{c}ois},
year = {1998},
pages = {321--332},
id = {162},
booktitle = {Proceedings of SIGGRAPH '98},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{LA05,
title = {Hierarchical Penumbra Casting},
author = {Laine, Samuli and Aila, Timo},
year = {2005},
pages = {313--322},
number = {3},
volume = {24},
id = {163},
journal = {Computer Graphics Forum (Proceedings of Eurographics '05)},
publisher = {Blackwell Publishers},
}
@InProceedings{Laine05,
title = {Split-Plane Shadow Volumes},
author = {Laine, Samuli},
year = {2005},
pages = {23--32},
id = {164},
booktitle = {Proceedings of the ACM SIGGRAPH/EUROGRAPHICS Workshop on Graphics Hardware},
publisher = {ACM Press},
}
@Article{LAALA05,
title = {Soft Shadow Volumes for Ray Tracing},
author = {Laine, Samuli and Aila, Timo and Assarson, Ulf and Lehtinen, Jaakko and Akenine-M{\"o}ller, Tomas},
year = {2005},
pages = {1156--1165},
id = {165},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2005)},
}
@InProceedings{KLA04,
title = {Hemispherical Rasterization for Self-Shadowing of Dynamic Objects},
author = {Kautz, Jan and Lehtinen, Jaakko and Aila, Timo},
year = {2004},
pages = {179-184},
id = {166},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Object{PSS98,
title = {Single sample soft shadows},
author = {Parker, Steven and Shirley, Peter and Smits, Brian},
year = {1998},
institution = {University of Utah},
number = {UUCS-98-019},
id = {167},
}
@InProceedings{CF92,
title = {Fast object-precision shadow generation for area light sources using BSP trees},
author = {Chin, Norman and Feiner, Steven},
year = {1992},
id = {168},
booktitle = {Proceedings of the 1992 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@Article{IH05,
title = {A Method to Generate Soft Shadows Using a Layered Depth Image and Warping},
author = {Im, Yeon-Ho and Han, Chang-Young},
year = {2005},
pages = {265--272},
id = {169},
journal = {IEEE Transaction on Visualization and Computer Graphics},
}
@InProceedings{HSB00,
title = {Soft Shadow Maps for Linear Lights},
author = {Heidrich, Wolfgang and Seidel, Hans-Peter and Brabec, Stefan},
year = {2000},
pages = {269--280},
id = {173},
booktitle = {Rendering Techniques '00 (Proceedings of the 11th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{AM05,
title = {Fast and Exact Direct Illumination},
author = {Aveneau, Lilian and Mora, Fr\'ed\'eric},
year = {2005},
id = {172},
booktitle = {Proceedings of Computer Graphics International '05},
publisher = {IEEE},
}
List of publications of visibility@Comment Generated with XdkBib.
@Comment 79 article(s).
@InProceedings{Teller92,
title = {Computing the antipenumbra of an area light source},
author = {Teller, Seth},
year = {1992},
id = {1},
booktitle = {Proceedings of the 1992 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@InProceedings{DDTP00,
title = {Conservative Visibility Preprocessing Using Extended Projections},
author = {Durand, Fr\'edo and Drettakis, George and Thollot, Jo{\"e}lle and Puech, Claude},
year = {2000},
pages = {239--248},
id = {2},
booktitle = {Proceedings of SIGGRAPH '00},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{CFH98,
title = {Conservative Visibility and Strong Occlusion for Viewspace Partitioning of Densely Occluded Scenes},
author = {Cohen-{O}r, Daniel and Fibich, Gadi and Halperin, Dan},
year = {1998},
pages = {243--255},
id = {3},
journal = {Computer Graphics Forum (Proceedings of Eurographics '98)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{SDDS00,
title = {Conservative Volumetric Visibility with Occluder Fusion},
author = {Schaufler, Gernot and Dorsey, Julie and D\'ecoret, Xavier and Sillion, Fran\c{c}ois},
year = {2000},
id = {4},
booktitle = {Proceedings of SIGGRAPH '00},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Object{Zhang98,
title = {Effective occlusion culling for the interactive display of arbitrary models},
author = {Zhang, Hansong},
year = {1998},
id = {5},
}
@Object{BP01,
title = {Exact Regional Visibility using Line Space Partitioning},
author = {Bittner, Ji\v{r}\'i and P\v{r}ikryl, Jan},
year = {2001},
institution = {Institute of Computer Graphics and Algorithms, Vienna University of Technology},
number = {TR-186-2-01-06},
id = {6},
}
@InProceedings{BMH98,
title = {Extending graphics hardware for occlusion queries in OpenGL},
author = {Bartz, Dirk and Mei{\ss}ner, Michael and H{\"u}ttner, Tobias},
year = {1998},
id = {7},
booktitle = {Proceedings of the ACM SIGGRAPH/EUROGRAPHICS Workshop on Graphics Hardware},
publisher = {ACM Press},
}
@InProceedings{GKM93,
title = {Hierarchical Z-buffer visibility},
author = {Greene, Ned and Kass, Michael and Miller, Gavin},
year = {1993},
pages = {231--238},
id = {8},
booktitle = {Proceedings of SIGGRAPH '93},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{WWS01,
title = {Instant Visibility},
author = {Wonka, Peter and Wimmer, Michael and Sillion, Fran\c{c}ois},
year = {2001},
id = {9},
journal = {Computer Graphics Forum (Proceedings of Eurographics '01)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{FST92,
title = {Management of large amounts of data in interactive building walkthroughs},
author = {Funkhouser, Thomas A. and S\'equin, Carlo and Teller, Seth},
year = {1992},
pages = {11--20},
id = {10},
booktitle = {Proceedings of the 1992 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@Article{WS99,
title = {Occluder Shadows for Fast Walkthroughs of Urban Environments},
author = {Wonka, Peter and Schmalstieg, Dieter},
year = {1999},
pages = {51--60},
id = {11},
journal = {Computer Graphics Forum (Proceedings of Eurographics '99)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{DAS01,
title = {Occlusion Horizons for Driving through Urban Scenery},
author = {Downs, Laura and Akenine-M{\"o}ller, Tomas and S\'equin, Carlo},
year = {2001},
pages = {121--124},
id = {12},
booktitle = {Proceedings of the 2001 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@InProceedings{LG95,
title = {Portals and mirrors: simple, fast evaluation of potentially visible sets},
author = {Luebke, David and Georges, Chris},
year = {1995},
id = {13},
booktitle = {Proceedings of the 1995 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@InProceedings{LT99,
title = {Preprocessing occlusion for real-time selective refinement},
author = {Law, Fei-Ah and Tan, Tiow-Seng},
year = {1999},
pages = {47--53},
id = {14},
booktitle = {Proceedings of the 1999 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@Article{LSC03,
title = {Ray Space Factorization for From-Region Visibility},
author = {Leyvand, Tommer and Sorkine, Olga and Cohen-{O}r, Daniel},
year = {2003},
id = {15},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2003)},
}
@InProceedings{CT97,
title = {Real-time occlusion culling for models with large occluders},
author = {Coorg, Satyan and Teller, Seth},
year = {1997},
id = {16},
booktitle = {Proceedings of the 1997 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@Object{Durand99,
title = {Visibilit\'e tridimensionnelle : \'Etude analytique et applications},
author = {Durand, Fr\'edo},
year = {1999},
id = {17},
}
@Article{TS91,
title = {Visibility Preprocessing for Interactive Walkthroughs},
author = {Teller, Seth and S\'equin, Carlo},
year = {1991},
pages = {61--69},
id = {18},
journal = {Computer Graphics (Proceedings of SIGGRAPH '91)},
publisher = {ACM SIGGRAPH},
}
@InProceedings{BWW01,
title = {Visibility Preprocessing for Urban Scenes using Line Space Subdivision},
author = {Bittner, Ji\v{r}\'i and Wonka, Peter and Wimmer, Michael},
year = {2001},
pages = {276--284},
id = {19},
booktitle = {Proceedings of Pacific Graphics (PG'01)},
publisher = {IEEE Computer Society},
}
@InProceedings{WWS00,
title = {Visibility Preprocessing with Occluder Fusion for Urban Walkthroughs},
author = {Wonka, Peter and Wimmer, Michael and Schmalstieg, Dieter},
year = {2000},
id = {20},
booktitle = {Rendering Techniques '00 (Proceedings of the 11th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Object{Teller92b,
title = {Visibility computation in densely occluded polyhedral environments},
author = {Teller, Seth},
year = {1992},
id = {21},
}
@InProceedings{ZMHH97,
title = {Visibility culling using hierarchical occlusion maps},
author = {Zhang, Hansong and Manocha, Dinesh and Hudson, Tom and Hoff, III, Kenneth E.},
year = {1997},
pages = {77--88},
id = {22},
booktitle = {Proceedings of SIGGRAPH '97},
series = {{\em Computer Graphics} Proceedings, Annual Conference Series},
publisher = {ACM SIGGRAPH},
}
@Article{PD90,
title = {Visibility, occlusion, and the aspect graph},
author = {Plantinga, Harry and Dyer, Charles R.},
year = {1990},
pages = {137--160},
id = {23},
journal = {International Journal of Computer Vision},
}
@InProceedings{HKW00,
title = {Conservative visibility preprocessing for walkthroughs of complex urban scenes},
author = {Heo, JunHyeok and Kim, Jaeho and Wohn, KwangYun},
year = {2000},
pages = {115--128},
id = {24},
booktitle = {Proceedings of the ACM Symposium on Virtual Reality Software and Technology},
publisher = {ACM Press},
}
@InProceedings{DDS03,
title = {Erosion Based Visibility Preprocessing},
author = {D\'ecoret, Xavier and Debunne, Gilles and Sillion, Fran\c{c}ois},
year = {2003},
id = {25},
booktitle = {Proceedings of the EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{BH01,
title = {Exploiting Temporal and Spatial Coherence in Hierarchical Visibility Algorithms},
author = {Bittner, Ji\v{r}\'i and Havran, Vlastimil},
year = {2001},
pages = {213--220},
id = {26},
booktitle = {Proceedings of Spring Conference on Computer Graphics (SCCG'01)},
publisher = {IEEE Computer Society},
}
@Object{HSLM02,
title = {Fast and Simple Occlusion Culling Based on Hardware Depth Queries},
author = {Hillesland, Karl and Salomon, Brian and Lastra, Anselmo and Manocha, Dinesh},
year = {2002},
institution = {UNC-CH},
number = {TR02-039},
id = {27},
}
@InProceedings{GJ01,
title = {Geometric Simplification for Efficient Occlusion Culling in Urban Scenes},
author = {Germs, Rick and {W}ann Jansen, Frederik},
year = {2001},
number = {TR02-039},
id = {28},
booktitle = {Proceedings of Winter School on Computer Graphics 2001},
}
@Object{Bittner02,
title = {Hierarchical Techniques for Visibility Computations},
author = {Bittner, Ji\v{r}\'i},
year = {2002},
type = {Departement of Computer Science and Engineering},
id = {29},
}
@InProceedings{BHS98,
title = {Hierarchical Visibility Culling with Occlusion Trees},
author = {Bittner, Ji\v{r}\'i and Havran, Vlastimil and Slav\'ik, Pavel},
year = {1998},
pages = {207--219},
id = {30},
booktitle = {Proceedings of Computer Graphics International '98},
publisher = {IEEE},
}
@InProceedings{HTP01,
title = {Real-Time Occlusion Culling with a Lazy Occlusion Grid},
author = {Hey, Heinrich and Tobler, Robert F. and Purgathofer, Werner},
year = {2001},
pages = {217--222},
id = {31},
booktitle = {Rendering Techniques '01 (Proceedings of the 12th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@Article{ASNB00,
title = {Integrating Occlusion Culling with Levels of Detail through Hardly-Visible Sets},
author = {And\'ujar, Carlos and Saona-V\'azquez, Carlos and Navazo, Isabel and Brunet, Pere},
year = {2000},
pages = {499-506},
id = {32},
journal = {Computer Graphics Forum (Proceedings of Eurographics '00)},
number = {3},
publisher = {Blackwell Publishers},
}
@Article{CCSD02,
title = {A Survey of Visibility for Walkthrough Applications},
author = {Cohen-{O}r, Daniel and Chrysanthou, Yiorgos and Silva, Cl\'audio T. and Durand, Fr\'edo},
year = {2002},
id = {33},
journal = {IEEE Transaction on Visualization and Computer Graphics},
}
@Article{PT02,
title = {Occlusion Culling Algorithms: A Comprehensive Survey},
author = {Pantazopoulos, Ioannis and Tzafestas, Spyros},
year = {2002},
pages = {123--156},
id = {34},
journal = {Journal of Intelligent and Robotic Systems},
}
@InProceedings{TPK01,
title = {The Magic of the {Z}-Buffer: {A} Survey},
author = {Theoharis, Theoharis and Papaioannou, Georgios and Karabassi, Evaggelia-Aggeliki},
year = {2001},
pages = {379--386},
id = {35},
booktitle = {Proceedings of Winter School on Computer Graphics 2001},
}
@Object{Gummerus03,
title = {Conservative From-point Visibility},
author = {Gummerus, Sampsa},
year = {2003},
school = {University of Tampere},
id = {36},
}
@InProceedings{KC00,
title = {Selecting Effective Occluders for Visibility Culling},
author = {Koltun, Vladlen and Cohen-{O}r, Daniel},
year = {2000},
school = {University of Tampere},
id = {37},
booktitle = {Eurographics Short Presentation},
}
@InProceedings{KCC00,
title = {Virtual Occluders: An Efficient Intermediate {PVS} representation},
author = {Koltun, Vladlen and Chrysanthou, Yiorgos and Cohen-{O}r, Daniel},
year = {2000},
school = {University of Tampere},
id = {38},
booktitle = {Rendering Techniques '00 (Proceedings of the 11th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{PS99,
title = {Efficient Compression Techniques for Precomputed Visibility},
author = {van de Panne, Michiel and Stewart, James},
year = {1999},
pages = {305-316},
id = {39},
booktitle = {Rendering Techniques '99 (Proceedings of the 10th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{HMCLHZ97,
title = {Accelerated occlusion culling using shadow frusta},
author = {Hudson, Tom and Manocha, Dinesh and Cohen, Jonathan D. and Lin, Ming C. and Hoff, III, Kenneth E. and Zhang, Hansong},
year = {1997},
pages = {1--10},
id = {40},
booktitle = {Proceedings of the 14th ACM Symposium on Computational Geometry},
}
@Article{BNSR01,
title = {Hoops: 3D Curves as Conservative Occluders for Cell-Visibility},
author = {Brunet, Pere and Navazo, Isabel and Saona-V\'azquez, Carlos and Rossignac, Jarek},
year = {2001},
id = {41},
journal = {Computer Graphics Forum (Proceedings of Eurographics '01)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{HBPF02,
title = {The global occlusion map: a new occlusion culling approach},
author = {Hua, Wei and Bao, Hujun and Peng, Qunsheng and Forrest, A. R.},
year = {2002},
pages = {155--162},
id = {42},
booktitle = {Proceedings of the ACM Symposium on Virtual Reality Software and Technology},
publisher = {ACM Press},
}
@InProceedings{MBHE01,
title = {Generation of Decomposition Hierarchies for Efficient Occlusion Culling of
Large Polygonal Models},
author = {Mei{\ss}ner, Michael and Bartz, Dirk and H{\"u}ttner, Tobias and Einighammer, J.},
year = {2001},
id = {43},
booktitle = {Proceedings of Vision,Modeling, and Visualization},
}
@Article{HDS03,
title = {Volumetric Cell-and-Portal Generation},
author = {Haumont, Denis and Debeir, Olivier and Sillion, Fran\c{c}ois},
year = {2003},
id = {44},
journal = {Computer Graphics Forum (Proceedings of Eurographics '03)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{LCC03,
title = {Breaking the Walls: Scene Partitioning and Portal Creation},
author = {Lerner, Alan and Chrysanthou, Yiorgos and Cohen-{O}r, Daniel},
year = {2003},
pages = {303},
id = {45},
booktitle = {Proceedings of Pacific Graphics (PG'03)},
publisher = {IEEE Computer Society},
}
@InProceedings{ZK03,
title = {Progressive Compression of Visibility Data for View-Dependent Multiresolution Meshes},
author = {Zach, Christopher and Karner, Konrad F.},
year = {2003},
pages = {546-553},
id = {46},
booktitle = {Proceedings of Winter School on Computer Graphics 2003},
}
@InProceedings{SHNGB03,
title = {Accelerating ray shooting through aggressive 5D visibility preprocessing},
author = {Sharpe, Adrian and Hampton, Matthew and Nirenstein, Shaun and Gain, James and Blake, Edwim},
year = {2003},
pages = {95--100},
id = {47},
booktitle = {Proceedings of the 2nd International Conference on Computer Graphics, Virtual Reality, Visualisation and Interaction in Africa},
publisher = {ACM Press},
}
@InProceedings{NBG02,
title = {Exact from-region visibility culling},
author = {Nirenstein, Shaun and Blake, Edwim and Gain, James},
year = {2002},
pages = {191--202},
id = {48},
booktitle = {Rendering Techniques '02 (Proceedings of the 13th EG Workshop on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
@InProceedings{CT96,
title = {Temporally Coherent Conservative Visibility},
author = {Coorg, Satyan and Teller, Seth},
year = {1996},
pages = {78--87},
id = {49},
booktitle = {Proceedings of the 13th ACM Symposium on Computational Geometry},
}
@InProceedings{Plantinga93,
title = {Conservative visibility preprocessing for efficient walkthrough of 3D scenes},
author = {Plantinga, Harry},
year = {1993},
pages = {166--173},
id = {50},
booktitle = {Proceedings of Graphics Interface},
}
@Article{SG99,
title = {Dynamic Scene Occlusion Culling},
author = {Sudarsky, Oded and Gotsman, Craig},
year = {1999},
pages = {13--29},
id = {51},
journal = {IEEE Transaction on Visualization and Computer Graphics},
}
@Article{SG96,
title = {Output-Sensitive Visibility Algorithms for Dynamic Scenes with Applications to Virtual Reality},
author = {Sudarsky, Oded and Gotsman, Craig},
year = {1996},
pages = {249--258},
id = {52},
journal = {Computer Graphics Forum (Proceedings of Eurographics '96)},
number = {3},
publisher = {NCC/Blackwell},
}
@Article{BK00,
title = {Directional Discretized Occluders for accelerated occlusion culling},
author = {Bernardini, Fausto and Klosowski, James T.},
year = {2000},
id = {53},
journal = {Computer Graphics Forum (Proceedings of Eurographics '00)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{Lim92,
title = {Toward a fuzzy hidden surface algorithm},
author = {Lim, Hong Lip},
year = {1992},
id = {54},
booktitle = {Proceedings of Computer Graphics International '92},
publisher = {IEEE},
}
@Article{KS00,
title = {The Prioritized-Layered Projection Algorithm for Visible Set Estimation},
author = {Klosowski, James T. and Silva, Cl\'audio T.},
year = {2000},
pages = {108--123},
id = {55},
journal = {IEEE Transaction on Visualization and Computer Graphics},
}
@InProceedings{GSYM03,
title = {Interactive visibility culling in complex environments using occlusion-switches},
author = {Govindaraju, Naga K. and Sud, Avneesh and Yoon, Sung-Eui and Manocha, Dinesh},
year = {2003},
pages = {103--112},
id = {56},
booktitle = {Proceedings of the 2003 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@InProceedings{AS99,
title = {Lod visibility culling and occluder synthesis},
author = {And\'ujar, Carlos and Saona-V\'azquez, Carlos},
year = {1999},
id = {57},
booktitle = {Computer Aided Design},
}
@Article{NRJS03,
title = {ShieldTester: Cell-to-Cell Visibility Test for Surface Occluders},
author = {Navazo, Isabel and Rossignac, Jarek and Jou, Joan and Shariff, Rahim},
year = {2003},
id = {58},
journal = {Computer Graphics Forum (Proceedings of Eurographics '03)},
number = {3},
publisher = {Blackwell Publishers},
}
@Article{AA00,
title = {Optimized View Frustum Culling Algorithms for Bounding Boxes},
author = {Assarson, Ulf and Akenine-M{\"o}ller, Tomas},
year = {2000},
id = {65},
journal = {Journal of Graphic Tools},
}
@Article{Clark76,
title = {Hierarchical geometric models for visible surface algorithms},
author = {Clark, James H.},
year = {1976},
pages = {547--554},
id = {66},
journal = {Communication of the ACM},
}
@InProceedings{ESS01,
title = {Integrating Occlusion Culling with View-dependent rendering},
author = {El-Sana, Jihad and Sokolovsky, Neta and Silva, Cl\'audio T.},
year = {2001},
pages = {371 -- 378 },
id = {67},
booktitle = {Proceedings of the conference on Visualization '01},
}
@Object{Aila00,
title = {SurRender Umbra: A Visibility Determination Framework for Dynamic Environments},
author = {Aila, Timo},
year = {2000},
school = {Helsinki University of Technology},
id = {72},
}
@Article{AM04,
title = {dPVS: An Occlusion Culling System for Massive Dynamic Environments},
author = {Aila, Timo and Miettinen, Ville},
year = {2004},
pages = {86--97},
school = {Helsinki University of Technology},
id = {73},
journal = {IEEE Computer Graphics \& Applications},
}
@InProceedings{HW91,
title = {Shaft culling for efficient ray-cast radiosity},
author = {Haines, Eric and Wallace, John R.},
year = {1991},
pages = {122--138},
school = {Helsinki University of Technology},
id = {74},
booktitle = {Photorealism Rendering in Computer Graphics (Proceedings of the 2nd Workshop on Rendering)},
organization = {Eurographics},
publisher = {Springer},
series = {Focus on Computer Graphics},
}
@InProceedings{Bittner02b,
title = {Efficient Construction of Visibility Maps using Approximate Occlusion Sweep},
author = {Bittner, Ji\v{r}\'i},
year = {2002},
id = {75},
booktitle = {Proceedings of Spring Conference on Computer Graphics (SCCG'02)},
publisher = {IEEE Computer Society},
}
@Article{GSF99,
title = {Optimized occlusion culling using five-dimensional subdivision},
author = {Gotsman, Craig and Sudarsky, Oded and Fayman, Jeffrey A.},
year = {1999},
pages = {645--654},
id = {76},
journal = {Computer \& Graphics},
}
@Article{Stewart97,
title = {Hierarchical Visibility in Terrains},
author = {Stewart, James},
year = {1997},
id = {77},
journal = {Computer Graphics Forum (Proceedings of Eurographics '97)},
number = {3},
publisher = {Blackwell Publishers},
}
@Object{BW03,
title = {Visibility in Computer Graphics},
author = {Bittner, Ji\v{r}\'i and Wonka, Peter},
year = {2003},
institution = {Institut für Computergraphik und Algorithmen},
number = {TR-186-2-03-03},
id = {107},
}
@Article{BWPP04,
title = {Coherent Hierarchical Culling: Hardware Occlusion Queries Made Useful},
author = {Bittner, Ji\v{r}\'i and Wimmer, Michael and Piringer, Harald and Purgathofer, Werner},
year = {2004},
number = {3},
id = {108},
journal = {Computer Graphics Forum (Proceedings of Eurographics '04)},
publisher = {Blackwell Publishers},
}
@Article{SBS04,
title = {Occlusion Culling in OpenSG PLUS},
author = {Staneker, Dirk and Bartz, Dirk and Stra{\ss}er, Wolfgang},
year = {2004},
pages = {87--92},
number = {TR-186-2-03-03},
id = {109},
journal = {Computer \& Graphics},
}
@Article{DD02,
title = {Robust epsilon visibility},
author = {Duguet, Florent and Drettakis, George},
year = {2002},
pages = {567 - 575 },
id = {110},
journal = {ACM Transactions on Graphics (Proceedings of SIGGRAPH 2002)},
}
@InProceedings{LE02,
title = {Horizon Occlusion Culling for Real-time Rendering of Hierarchical Terrains},
author = {Lloyd, Brandon and Egbert, K., Parris},
year = {2002},
pages = {403-409},
id = {111},
booktitle = {Proceedings of the conference on Visualization '02},
}
@Article{J O00,
title = {Efficient Algorithms for Computing Conservative Portal Visibility Information},
author = {Jimen\'ez, W.F.H. and Esperan{\~c}a, C. and Oliveira, A.A.F.},
year = {2000},
id = {112},
journal = {Computer Graphics Forum (Proceedings of Eurographics '00)},
number = {3},
publisher = {Blackwell Publishers},
}
@InProceedings{HW99,
title = {Occlusion Culling Using Minimum Occluder Set and Opacity Map},
author = {Ho, Poon Chun and Wang, Wenping},
year = {1999},
pages = {292},
id = {113},
booktitle = {Proceedings of International Conference on Information Visualization '99},
}
@InProceedings{MAM05,
title = {Coherent and Exact Polygon-to-Polygon Visibility},
author = {Mora, Fr\'ed\'eric and Aveneau, Lilian and M\'eriaux, Michel},
year = {2005},
id = {114},
booktitle = {Proceedings of Winter School on Computer Graphics 2005},
}
@InProceedings{Laine05,
title = {A General Algorithm for Output-Sensitive Visibility Preprocessing},
author = {Laine, Samuli},
year = {2005},
id = {115},
booktitle = {Proceedings of the 2005 Symposium on Interactive 3D graphics},
publisher = {ACM Press},
}
@Article{LD05,
title = {A New Technique for Rendering Complex Portals},
author = {Lowe, Nick and Datta, Amitava},
year = {2005},
pages = {81-90},
id = {116},
journal = {IEEE Transaction on Visualization and Computer Graphics},
}
@InProceedings{KF01,
title = {Occlusion Culling for Virtual Environments based on the 3D-Sectorgraph},
author = {Klein, Jan and Fischer, Matthias},
year = {2001},
pages = {275-278},
id = {117},
booktitle = {Proceedings of 3. GI-Informatiktage 2001},
}
@InProceedings{NB04,
title = {Hardware Accelerated Visibility Preprocessing using Adaptive Sampling},
author = {Nirenstein, Shaun and Blake, Edwim},
year = {2004},
pages = {207-216},
id = {155},
booktitle = {Proceedings of the 2nd EG Symposium on Rendering},
organization = {Eurographics},
series = {Springer Computer Science},
publisher = {Eurographics Association},
}
June 17 Color Conversion AlgorithmsContents
The Hue/Saturation/Value model was created by A. R. Smith in 1978. It is based on such intuitive color characteristics as tint, shade and tone (or family, purety and intensity). The coordinate system is cylindrical, and the colors are defined inside a hexcone. The hue value H runs from 0 to 360º. The saturation S is the degree of strength or purity and is from 0 to 1. Purity is how much white is added to the color, so S=1 makes the purest color (no white). Brightness V also ranges from 0 to 1, where 0 is the black. There is no transformation matrix for RGB/HSV conversion, but the algorithm follows: // r,g,b values are from 0 to 1 // h = [0,360], s = [0,1], v = [0,1] // if s == 0, then h = -1 (undefined) void RGBtoHSV( float r, float g, float b, float *h, float *s, float *v )
{
float min, max, delta;min = MIN( r, g, b ); max = MAX( r, g, b ); *v = max; // v delta = max - min; if( max != 0 )
*s = delta / max; // s
else {
// r = g = b = 0 // s = 0, v is undefined
*s = 0;
*h = -1;
return;
}if( r == max ) *h = ( g - b ) / delta; // between yellow & magenta else if( g == max ) *h = 2 + ( b - r ) / delta; // between cyan & yellow else *h = 4 + ( r - g ) / delta; // between magenta & cyan *h *= 60; // degrees if( *h < 0 ) *h += 360; } void HSVtoRGB( float *r, float *g, float *b, float h, float s, float v )
{
int i;
float f, p, q, t; if( s == 0 ) {
// achromatic (grey)
*r = *g = *b = v;
return;
}h /= 60; // sector 0 to 5 i = floor( h ); f = h - i; // factorial part of h p = v * ( 1 - s ); q = v * ( 1 - s * f ); t = v * ( 1 - s * ( 1 - f ) ); switch( i ) {
case 0:
*r = v;
*g = t;
*b = p;
break;
case 1:
*r = q;
*g = v;
*b = p;
break;
case 2:
*r = p;
*g = v;
*b = t;
break;
case 3:
*r = p;
*g = q;
*b = v;
break;
case 4:
*r = t;
*g = p;
*b = v;
break;
default: // case 5:
*r = v;
*g = p;
*b = q;
break;
}} When programming in Java, use the RGBtoHSB and HSBtoRGB functions from the java.awt.Color class. The YIQ system is the color primary system adopted by National Television System Committee (NTSC) for color TV broadcasting. The YIQ color solid is made by a linear transformation of the RGB cube. Its purpose is to exploit certain characteristics of the human eye to maximize the utilization of a fixed bandwidth. The human visual system is more sensitive to changes in luminance than to changes in hue or saturation, and thus a wider bandwidth should be dedicated to luminance than to color information. Y is similar to perceived luminance, I and Q carry color information and some luminance information. The Y signal usually has 4.2 MHz bandwidth in a 525 line system. Originally, the I and Q had different bandwidths (1.5 and 0.6 MHz), but now they commonly have the same bandwidth of 1 MHz. Here is the RGB -> YIQ conversion: [ Y ] [ 0.299 0.587 0.114 ] [ R ] Here is the YIQ -> RGB conversion: [ R ] [ 1 0.956 0.621 ] [ Y ] RGB values in a particular set of primaries can be transformed to and from CIE XYZ via a 3x3 matrix transform. These transforms involve tristimulus values, that is a set of three linear-light components that conform to the CIE color-matching functions. CIE XYZ is a special set of tristimulus values. In XYZ, any color is represented as a set of positive values. To transform from XYZ to RGB (with D65 white point), the matrix transform used is [3]: [ R ] [ 3.240479 -1.537150 -0.498535 ] [ X ] The range for valid R, G, B values is [0,1]. Note, this matrix has negative coefficients. Some XYZ color may be transformed to RGB values that are negative or greater than one. This means that not all visible colors can be produced using the RGB system. The inverse transformation matrix is as follows: [ X ] [ 0.412453 0.357580 0.180423 ] [ R ] ** ** February 20, 2000 - typo in this line of the matrix was corrected (0.189423 to 0.180423), thanks to Michal Karczmarek, University of Toronto XYZ to CIE L*a*b* (CIELAB) & CIELAB to XYZ CIE 1976 L*a*b* is based directly on CIE XYZ and is an attampt to linearize the perceptibility of color differences. The non-linear relations for L*, a*, and b* are intended to mimic the logarithmic response of the eye. Coloring information is referred to the color of the white point of the system, subscript n.
Here Xn, Yn and Zn are the tristimulus values of the reference white.
CIE 1976 L*u*u* (CIELUV) is based directly on CIE XYZ and is another attampt to linearize the perceptibility of color differences. The non-linear relations for L*, u*, and v* are given below:
The quantities un' and vn' refer to the reference white or the light source; for the 2° observer and illuminant C, un' = 0.2009, vn' = 0.4610 [ 1 ]. Equations for u' and v' are given below: u' = 4X / (X + 15Y + 3Z) = 4x / ( -2x + 12y + 3 ) The transformation from (u',v') to (x,y) is: x = 27u' / ( 18u' - 48v' + 36 )
Disclaimer: I (N. Schaller) received e-mail from Alexandre Campo (acampo@laas.fr) stating that he felt the last three lines above should be Y = (( L* + 16 ) / 116 )^3 * Yn and then simplify by noticing u'v' - u'v' -4v' = -4v' X = 9Yu' / 4v' I have not verified this, but have added it for your purusal.
June 10 潜规则老外的想法做法就是不一样，如果你想在外企工作得好，有些潜规则你最好心里有数。 April 29 Gem: A Generic Handle-Based Resource ManagerBy Scott Bilas
IntroductionAll computer applications are databases. They spend most of their time juggling data resources – creating, destroying, caching, modifying, querying, saving, and restoring objects of various types. Games typically contain multiple types of databases, each of which is generally hard coded for each different case to keep things speedy. Some examples of game databases are file systems, texture managers, font managers, game actor managers. On top of those, there will also be a wide variety of domain-specific databases that completely depend on the game’s genre and content. A resource database that’s built into all C++ games is the basic object memory manager. A programmer calls new to construct a new object and passes its pointer around for other objects to pass it messages. When the object is no longer needed, somebody deletes it and its resources are returned to the system. This method works great in general, but it breaks down when we have to worry about shared resources. This is where we need a more specialized database. Let’s use a font object for our example. The font would at minimum consist of a bitmap and a set of specifications, such as the X,Y (or U,V) locations of its character cells, so the graphics system can render it to the screen. Such an object is fairly heavy duty in terms of memory usage and creation time. Different systems in the game, such as the development console and a text control within the GUI, will want to use font objects, but we can’t have each system creating its own local copy of the font object. Obviously, this would be slow and use up a lot of memory. To solve this problem we’ll come up with a way to share font objects. Chances are the solution will be called the FontMgr and will feature methods that get pointers to fonts, loading them in on the fly and caching them until they are no longer needed. The FontMgr will be made available from a global location (possibly as a Singleton) and will be responsible for all the font objects in the system. What we’re really talking about here is a specialized database. The FontMgr will be responsible for juggling font resources and, now that it’s considered an API, will suddenly take on additional responsibilities as the central clearing house for fonts. What if someone tells it to delete a font to free up resources, but some systems in the game still have pointers to it? How do we guarantee safety of the system without sacrificing performance? Will we be copy-pasting this code again (with slight tweaks) when it comes time to build the MousePointerMgr? This gem presents a simple, safe, generic, and efficient way to manage controlled resource objects. MethodThe job of a resource manager is to create resources on demand, hand them out to anyone who asks, and then eventually delete them. Handing out those resources as simple pointers is certainly easy and convenient, but it’s not a very safe way to do it. Pointers can “dangle” – one part of the system may tell the resource manager to delete a resource, which then immediately invalidates all other outstanding pointers. There’s no good way to prevent the dangling pointer problem from happening, and the only way we would find out that someone was attempting to dereference a deleted object is when the access violation dialog box comes up and the game crashes. The problem is that, with pointers, there’s no way to know how many references are outstanding, given that clients can copy the pointers as many times as they like without telling the manager about it. Another problem is that the underlying data organization can’t change with pointers. Any reallocation of buffers would immediately invalidate all outstanding pointers. This becomes especially important with saving the game to disk. Pointers can’t be saved to disk because the next time the game is loaded, system memory will probably be configured differently or we may even be on a completely different machine. The pointers must be converted into a form that can be restored, which will probably be an offset or a unique identifier of some sort. Working around this problem isn’t exactly trivial and can require a lot of work to support in client code. So it’s plainly not a good idea for a safe and flexible resource manager to be handing out pointers. Rather than using pointers, or attempting to write some kind of super-intelligent over-complicated “smart pointer”, we can add one layer of abstraction and use handles instead, and put the burden on the manager class. Handles are an ancient programming concept that API’s have been using with great success for decades. An example of this is the HANDLE type returned by the CreateFile() call in Win32’s file system. A file handle, representing an open file system object, is created through the CreateFile() call, passed to other functions such as ReadFile() and SetFilePointer() for manipulation, and then finally closed off with CloseHandle(). Attempting to call those functions with an invalid or closed handle will not cause a crash, but will instead return an error code. This method is efficient, safe, and easy to understand. Handles almost always fit into a single CPU register for efficient storage in collections and passing as parameters to functions. They can be easily checked for validity and provide a level of indirection that allows the underlying data organization to change without invalidating any outstanding handles. This has significant advantages over passing around pointers. Handles can also be easily saved to disk, because the data structures they refer to can be reconstructed in the same order on a game restore. This allows the handles to be stored directly with no conversions necessary, because they are already natively in unique identifier form. The Handle ClassA fast and safe way to represent handles is to use an unsigned integer composed of two bitfield components (this class appears in Listing 1). The first component (m_Index) is a unique identifier for fast dereferencing into the handle manager’s database. The handle manager can use this number however it likes, but perhaps the most efficient is as a simple index into an std::vector. The second component (m_Magic) is a “magic number” that can be used to validate the handle. Upon dereferencing, the handle manager can check to make sure that the magic number component of the handle matches up with its corresponding entry in the database. The Handle class is very simple and really doesn’t do much except manage the magic number. Upon calling Init(), the handle will be given the next magic number, which auto increments and will wrap around if necessary. Note that the magic number is not intended to be a GUID. Its purpose is to serve as a very simple and fast validity check and is relying on the high improbability of a condition arising where one object happens to have the same index and magic number (via wrapping) as another. The magic number of zero is reserved for the “null handle” – where the handle’s data is zero. The default Handle constructor sets itself to null, a state that will return true on an IsNull() query. This is convenient to use for an error condition – a function that creates an object and returns a handle to it can just return a null handle to indicate an error occurred. In most ways the Handle class will act as a read-only unsigned integer. It’s not intended to be modified after being created, though it can safely be assigned back to null to reset it. You’ll notice that it’s a parameterized class, taking a TAG type in order to fully define it. The template parameter TAG doesn’t do anything except differentiate among types of handles – an object of type TAG is never used anywhere in the system. The motivation here is type safety. Without parameterizing Handle, a handle meant for one type of resource could be passed to a function expecting a handle to a different type of resource without a complaint from the compiler. So to keep things safe, we create a new handle type, taking any unique symbol and using it for the parameter. The TAG type can really be anything so long as it’s unique across Handle types, but it’s convenient to define an empty struct and use that in the typedef for a handle, like this texture handle example: struct tagTexture { }; typedef Handle <tagTexture> HTexture;
Now we need a handle manager that is responsible for acquiring, dereferencing, and releasing objects (via handles) for a higher-level owner. The HandleMgr ClassThe HandleMgr class is a parameterized type composed of three main elements: a data store, a magic number store, and a free list (this class appears in Listing 2). The data store is simply a vector (or any other randomly accessible collection) of objects of type DATA. The DATA type, the first type parameter for HandleMgr, should be a very simple class that contains context information about the resource that it controls. For example, in a HandleMgr that manages files, the DATA type would probably just have the file handle and the name of the file: struct FileEntry { std::string m_FileName; HANDLE m_FileHandle; // OS file handle };
struct tagFile { }; typedef Handle <tagFile> HFile; typedef HandleMgr <FileEntry, HFile> FileHandleMgr;
This simple handle manager will maintain a set of context objects that correspond to all the open files that it knows about. The FileHandleMgr class will probably not be used directly by clients, but will instead be owned by another class (call it FileMgr) that handles the abstraction and knows about the problem domain (that is, what DATA is supposed to represent). This class might look something like this: class FileMgr { FileHandleMgr m_Mgr;
public: HFile OpenFile ( const char* name ); bool ReadFile ( HFile file, void* out, size_t bytes ); bool CloseFile( HFile file );
// ... };
Upon calling any of these methods, FileMgr will ask its m_Mgr to dereference the handle to get at the actual FileEntry object. After verifying that the dereference succeeded (it will fail on an invalid handle), it will then perform the operation. For our HandleMgr class, each handle will reference exactly one element within the object store, plus its corresponding element in the magic number store. Dereferencing the handles to get at the actual FileEntry object is as simple as using the m_Index component of the handle as an index into the object store (a very fast operation). When dereferencing the handle, the code will also check the m_Magic component against the same index in the magic number store to make sure the handle is valid. As handles are freed and reacquired, corresponding entries in the magic number store are updated with the new handle magic numbers. This nearly guarantees that “dangling” handles on released objects won’t refer to unexpected objects when the slots are filled by a later handle acquisition, but will instead simply fail to work and return an error code. Obviously, the magic number store will always have the same number of elements as the object store. As objects are released, the handle manager will add the indexes of the slots they occupy to the free list. This saves it the trouble of needing to search through the object store to find an open slot, which results in a tasty O(n) complexity for new handle acquisition. It’s important to note that the DATA type is not your typical C++ class. It shouldn’t have constructors and destructors that do anything important, such as acquire and release local resources. Objects contained within the object store are constructed, destroyed, and copied as the vector class sees fit. Note that the std::string used in the sample FileEntry is “simple” enough for our needs – it’s reference-counted, which minimizes the impact of its constructors and destructors and makes it nearly free for vector to copy. When asked to acquire an object from the store, we’ll likely end up reusing an object that has already been constructed but is no longer in use, as indicated by its entry in the free list. It will need its members reinitialized before it can be used, because it won’t have had the constructor call to set it up. When an object is freed from the store, it will not get destroyed, but will instead have its index added to the free list, and as such will need its resources manually freed. These minor limitations arise from the fact that we’re embedding our DATA type directly in the vector, rather than using pointers and creating and destroying the objects with new and delete for each handle acquisition and release. The major advantage here is speed, in that the objects don’t have to be completely brought up and shut down each time. To make things more convenient, the initialize/shutdown code can be moved into member functions for easy callback by the HandleMgr owner. The amount of handle validation necessary may depend on the application, and could even be chosen through an additional template parameter for HandleMgr. For example, the test for an invalid handle may be found to be unnecessary and could be removed (though the debug assertion should always remain). For a more robust system where error handling is important, the code could, upon detecting an invalid handle, set an error condition, and then abort the function call. Sample UsageIn Listing 3 I provide a sample texture manager class. This class allows clients to ask it for textures by name and will construct them on demand. It automatically unloads the textures on deletion, and provides a set of query functions to use the textures. The textures are indexed by name for speedy lookup to make sure that the same texture is not added to the store twice. It would be a simple exercise to add reference counting to this example to make it safer, replacing DeleteTexture() with ReleaseTexture(). For another (larger) sample of file handle usage, see the sample code for my GDC 2000 talk, It’s Still Loading? Designing an Efficient File System, available from http://www.drizzle.com/~scottb/gdc/. NotesThe HandleMgr class is very simple and is meant to illustrate some basic concepts, but it can be expanded in a number of ways, either with the existing HandleMgr or separate classes: · Create a HandleMgr that will work better with larger DATA objects, holding them indirectly through pointers. It would also allow hiding of the data structure to clients. · Add automatic reference counting as standard functionality, rather than leaving it to be the responsibility of the owner of the HandleMgr. · Add support for constant-time iteration over the potentially sparse object store by embedding a linked list within its elements. Use STL style iterator naming and operation for consistency. · Many databases, such as a font manager or texture manager, will likely require indexes to access objects by name to retrieve handles. Build this in as a standard feature or as a separate (derivative) class. · The HandleMgr system is especially effective when combined with the Singleton pattern (see “An Automatic Singleton Utility” elsewhere in this book). Many of a game’s databases are naturally singletons. · Take the Singleton pattern a little further, and make the TAG type of Handle actually be the type that it corresponds to within the HandleMgr. Then the Handle could have an operator -> that would dereference itself into a TAG by directly accessing the Singleton that manages it. · Save game functionality should be fairly easy to add, but it is necessarily specific to your game’s architecture. The handles can be saved out directly – just make sure that the HandleMgr stores the indexes for its objects along with the object data, and on restore, all handles will remain valid. Listing 1 – Handle#include <cassert>
template <typename TAG> class Handle { union { enum { // sizes to use for bit fields MAX_BITS_INDEX = 16, MAX_BITS_MAGIC = 16,
// sizes to compare against for asserting dereferences MAX_INDEX = ( 1 << MAX_BITS_INDEX) - 1, MAX_MAGIC = ( 1 << MAX_BITS_MAGIC) - 1, };
struct { unsigned m_Index : MAX_BITS_INDEX; // index into resource array unsigned m_Magic : MAX_BITS_MAGIC; // magic number to check }; unsigned int m_Handle; };
public:
// Lifetime.
Handle( void ) : m_Handle( 0 ) { }
void Init( unsigned int index );
// Query.
unsigned int GetIndex ( void ) const { return ( m_Index ); } unsigned int GetMagic ( void ) const { return ( m_Magic ); } unsigned int GetHandle( void ) const { return ( m_Handle ); } bool IsNull ( void ) const { return ( !m_Handle ); }
operator unsigned int ( void ) const { return ( m_Handle ); } };
template <typename TAG> void Handle <TAG> :: Init( unsigned int index ) { assert( IsNull() ); // don't allow reassignment assert( index <= MAX_INDEX ); // verify range
static unsigned int s_AutoMagic = 0; if ( ++s_AutoMagic > MAX_MAGIC ) { s_AutoMagic = 1; // 0 is used for "null handle" }
m_Index = index; m_Magic = s_AutoMagic; }
template <typename TAG> inline bool operator != ( Handle <TAG> l, Handle <TAG> r ) { return ( l.GetHandle() != r.GetHandle() ); }
template <typename TAG> inline bool operator == ( Handle <TAG> l, Handle <TAG> r ) { return ( l.GetHandle() == r.GetHandle() ); } Listing 2 – HandleMgr#include <vector> #include <cassert>
template <typename DATA, typename HANDLE> class HandleMgr { private: // private types typedef std::vector <DATA> UserVec; typedef std::vector <unsigned int> MagicVec; typedef std::vector <unsigned int> FreeVec;
// private data UserVec m_UserData; // data we're going to get to MagicVec m_MagicNumbers; // corresponding magic numbers FreeVec m_FreeSlots; // keeps track of free slots in the db
public:
// Lifetime.
HandleMgr( void ) { } ~HandleMgr( void ) { }
// Handle methods.
// acquisition DATA* Acquire( HANDLE& handle ); void Release( HANDLE handle );
// dereferencing DATA* Dereference( HANDLE handle ); const DATA* Dereference( HANDLE handle ) const;
// other query unsigned int GetUsedHandleCount( void ) const { return ( m_MagicNumbers.size() - m_FreeSlots.size() ); } bool HasUsedHandles( void ) const { return ( !!GetUsedHandleCount() ); } };
template <typename DATA, typename HANDLE> DATA* HandleMgr <DATA, HANDLE> :: Acquire( HANDLE& handle ) { // if free list is empty, add a new one otherwise use first one found
unsigned int index; if ( m_FreeSlots.empty() ) { index = m_MagicNumbers.size(); handle.Init( index ); m_UserData.push_back( DATA() ); m_MagicNumbers.push_back( handle.GetMagic() ); } else { index = m_FreeSlots.back(); handle.Init( index ); m_FreeSlots.pop_back(); m_MagicNumbers[ index ] = handle.GetMagic(); } return ( m_UserData.begin() + index ); }
template <typename DATA, typename HANDLE> void HandleMgr <DATA, HANDLE> :: Release( HANDLE handle ) { // which one? unsigned int index = handle.GetIndex();
// make sure it's valid assert( index < m_UserData.size() ); assert( m_MagicNumbers[ index ] == handle.GetMagic() );
// ok remove it - tag as unused and add to free list m_MagicNumbers[ index ] = 0; m_FreeSlots.push_back( index ); }
template <typename DATA, typename HANDLE> inline DATA* HandleMgr <DATA, HANDLE> :: Dereference( HANDLE handle ) { if ( handle.IsNull() ) return ( 0 );
// check handle validity - $ this check can be removed for speed // if you can assume all handle references are always valid. unsigned int index = handle.GetIndex(); if ( ( index >= m_UserData.size() ) || ( m_MagicNumbers[ index ] != handle.GetMagic() ) ) { // no good! invalid handle == client programming error assert( 0 ); return ( 0 ); }
return ( m_UserData.begin() + index ); }
template <typename DATA, typename HANDLE> inline const DATA* HandleMgr <DATA, HANDLE> :: Dereference( HANDLE handle ) const { // this lazy cast is ok - non-const version does not modify anything typedef HandleMgr <DATA, HANDLE> ThisType; return ( const_cast <ThisType*> ( this )->Dereference( handle ) ); } Listing 3 – Sample Managed Class#include <vector> #include <map> #include <cassert>
// ... [ platform-specific surface handle type here ] typedef LPDIRECTDRAWSURFACE7 OsHandle;
struct tagTexture { }; typedef Handle <tagTexture> HTexture;
class TextureMgr {
// Texture object data and db.
struct Texture { typedef std::vector <OsHandle> HandleVec;
std::string m_Name; // for reconstruction unsigned int m_Width; // mip 0 width unsigned int m_Height; // mip 1 width HandleVec m_Handles; // handles to mip surfaces
OsHandle GetOsHandle( unsigned int mip ) const { assert( mip < m_Handles.size() ); return ( m_Handles[ mip ] ); }
bool Load ( const std::string& name ); void Unload( void ); };
typedef HandleMgr <Texture, HTexture> HTextureMgr;
// Index by name into db.
// case-insensitive string comparison predicate struct istring_less { bool operator () ( const std::string& l, const std::string& r ) const { return ( ::stricmp( l.c_str(), r.c_str() ) < 0 ); } };
typedef std::map <std::string, HTexture, istring_less > NameIndex; typedef std::pair <NameIndex::iterator, bool> NameIndexInsertRc;
// Private data.
HTextureMgr m_Textures; NameIndex m_NameIndex;
public:
// Lifetime.
TextureMgr( void ) { /* ... */ } ~TextureMgr( void );
// Texture management.
HTexture GetTexture ( const char* name ); void DeleteTexture( HTexture htex );
// Texture query.
const std::string& GetName( HTexture htex ) const { return ( m_Textures.Dereference( htex )->m_Name ); } int GetWidth( HTexture htex ) const { return ( m_Textures.Dereference( htex )->m_Width ); } int GetHeight( HTexture htex ) const { return ( m_Textures.Dereference( htex )->m_Height ); } OsHandle GetTexture( HTexture htex, unsigned int mip = 0 ) const { return ( m_Textures.Dereference( htex )->GetOsHandle( mip ) ); } };
TextureMgr :: ~TextureMgr( void ) { // release all our remaining textures before we go NameIndex::iterator i, begin = m_NameIndex.begin(), end = m_NameIndex.end(); for ( i = begin ; i != end ; ++i ) { m_Textures.Dereference( i->second )->Unload(); } }
HTexture TextureMgr :: GetTexture( const char* name ) { // insert/find NameIndexInsertRc rc = m_NameIndex.insert( std::make_pair( name, HTexture() ) ); if ( rc.second ) { // this is a new insertion Texture* tex = m_Textures.Acquire( rc.first->second ); if ( !tex->Load( rc.first->first ) ) { DeleteTexture( rc.first->second ); rc.first->second = HTexture(); } } return ( rc.first->second ); }
void TextureMgr :: DeleteTexture( HTexture htex ) { Texture* tex = m_Textures.Dereference( htex ); if ( tex != 0 ) { // delete from index m_NameIndex.erase( m_NameIndex.find( tex->m_Name ) );
// delete from db tex->Unload(); m_Textures.Release( htex ); } }
bool TextureMgr::Texture :: Load( const std::string& name ) { m_Name = name; // ... [ load texture from file system, return false on failure ] return ( true /* or false on error */ ); }
void TextureMgr::Texture :: Unload( void ) { m_Name.erase(); // ... [ free up mip surfaces ] m_Handles.clear(); } |
|||
|
|
