No announcement yet.

Unreal Engine 1

  • Filter
  • Time
  • Show
Clear All
new posts

    The creator of Unreal 227 patch, Smirftsch from OldUnreal, already have the source code.
    Why just not to give him permission to enable public access to libraries?


      As somebody just getting into graphics programming, the idea is nice and I hope a UE1 source release occurs. A potential effect of any source release of an engine is the learning opportunities they bring for younger system programmers. While that part of the industry may enjoy being less competitive than others for better or worse, enthusiasts inadvertently take initiative when they occupy themselves with their technical hobbies, and those are kinds of people you want working in your industry as technology and demands continue to evolve. Not that I'm trying to convince anyone here; we all seem fairly enthusiastic for a release of the engine source. But it's a productive example I wanted to highlight.

      Originally posted by Torax
      The creator of Unreal 227 patch, Smirftsch from OldUnreal, already have the source code.
      Why just not to give him permission to enable public access to libraries?
      Smirftsch's goal with the engine has been to expand the functionality of the original Unreal/UGold games' engine. It's a similar goal to the one many have voiced in this thread, but not directly related to actually releasing the source. Of course he has some form of the engine's source code, but working with Epic to distribute the code is not his responsibility if Epic themselves decide to push a release. They also have an opportunity to tailor and clean up the code to their liking, and update what's there at a later date if it occurs to them to do so.

      For a proper release, it's likely that Epic would want to use a repository for people to clone and fork, like with UE4. This is generally the proper way to manage digital projects and source code distribution, and Epic would be the primary party responsible for doing so.

      ModDb Portfolio


        Source is about new about new code for UT,Unreal 1,Whell of time (is active Mark Poesh yet?)..
        OpenSource will be clean version 533 or 613 with DX7,OpenGL..
        UE1 is about simlicity..(minimum actors,scripts,properties - ver.200 Unreal 1 rulez)..(but basic function: Pawn from Unreal 1,dynamic shadow, decal, static mesh)
        UE1 will be as demoscene on Unreal engine and engine general (veryfast compile, easy build, fast modeling, less megabytes).
        Nothing adjustments or extensions.
        Important is modeling and gameplay....
        Last edited by Akyra; 02-09-2015, 03:18 PM.


          Epic Unreal Dev Grants for UE4. Unreal is good idea...but not for me. I believe than I will make game on for players not for money..


            I would be definitely interested to see UE1 sources! It would be interesting to compare them to UE4 sources, to see how it's all started. Perhaps, there are still some lines of code that didn't change significantly since UE1 :P
            Realistic Atmosphere 2.0 | YouTube | Forum | Marketplace


              Where can I find the latest source code? Can you direct me to the link. thanks!


                Originally posted by DavidWilliams777 View Post
                Where can I find the latest source code? Can you direct me to the link. thanks!
                Create an account on, link it with your GitHub account, and then you can download the latest UE4 source code from
                Last edited by gmpreussner; 03-23-2015, 11:29 AM. Reason: removed duplicate quote
                Gerke Max Preussner | UE4 Programming Consultant

                Follow me on Github | Goodreads | Linkedin | Pinterest | SlideShare | Twitter.
                Chat with me as gmpreussner on Discord.


                  Uff...this Post is about UE1 source no about UE4..

                  Ilustration about latest version UE1 ver.533 is demo Mobile Forces developed by Rage Software. (Has static meshes and firs code for projector). MF has D3Ddriver DX8, because MF was release in 2002. Original ver. 533 was with D3DDriver 7. D3DDriver 8 MF include error ... detail texture works incorrect..


                    In Render in UnLight in Ut version was description:

                    Computes all point lighting information and builds surface light meshes
                    based on light actors and shadow maps.

                    The amount by which light diminishes as it travells from a point source
                    outward through space. Physically correct attenuation is propertional to
                    1/(distance*distance), but for speed, Unreal uses a lookup table
                    approximation where all light ceases after a light's predefined radius.
                    diffuse lighting:
                    Viewpoint-invariant lighting on a surface that is the result of a light's
                    brightness and a surface texture's diffuse lighting coefficient.
                    dynamic light:
                    A light that does not move, but has special effects.
                    illumination map:
                    A 2D array of floating point or MMX Red-Green-Blue-Unused values which
                    represent the illumination that a light applies to a surface. An illumination
                    map is the result of combining a light's spatial effects, attenuation,
                    incidence factors, and shadow map.
                    The angle at which a ray of light hits a point on a surface. Resulting brightness
                    is directly proportional to incidence.
                    Any actor whose LightType member has a value other than LT_None.
                    A mesh element; a single point in the rectangular NxM mesh containing lighting or
                    shadowing values.
                    moving light:
                    A light that moves. Moving lights do not cast shadows.
                    The process of determining the surface lighting resulting from
                    propagation of light through an environment, accounting for interreflection
                    as well as direct light propagation. Radiosity is a computationally
                    expensive preprocessing step but generates physically correct lighting.
                    The process of tracing rays through a level between lights and map lattice points
                    to precalculate shadow maps, which are later filtered to provide smoothing.
                    Raytracing generates cool looking though physically unrealistic lighting.
                    resultant map:
                    The final 2D array of floating point or MMX values which represent the total
                    illumination resulting from all of the lights (and hence illumination maps)
                    which apply to a surface.
                    shadow map:
                    A 2D array of floating point values which represent the amount of shadow
                    occlusion between a light and a map lattice point, from 0.0 (fully occluded)
                    to 1.0 (fully visible).
                    shadow hypervolume:
                    The six-dimensional hypervolume of space which is not affected by a volume
                    shadow volume:
                    The volume of space which is not affected by a point lightsource. The inverse of light
                    shadow z-buffer:
                    A 2D z-buffer representing a perspective projection depth view of the world from a
                    lightsource. Often used in dynamic shadowing computations.
                    spatial lighting effect:
                    A lighting effect that is a function of a location in space, usually relative to
                    a light's location.
                    specular lighting:
                    Viewpoint-varient lighting on a shiny surface that is the result of a
                    light's brightness and a surface texture's specular lighting
                    static illumination map:
                    An illumination map that represents the total of all static light illumination
                    maps that apply to a surface. Static illumination maps do not change in time
                    and thus they can be cached.
                    static light:
                    A light that is constantly on, does not move, and has no special effects.
                    surface map:
                    Any 2D map that applies to a surface, such as a shadow map or illumination
                    map. Surface maps are always aligned to the surface's U and V texture
                    coordinates and are bilinear filtered across the extent of the surface.
                    volumetric lighting:
                    Lighting that is visible as a result of light interacting with a volume in
                    space due to an interacting media such as fog. Volumetric lighting is view
                    variant and cannot be associated with a particular surface.

                    Design notes:
                    * Uses a multi-tiered system for generating the resultant map for a surface,
                    where all known constant intermediate and resulting meshes that may be needed
                    in the future are cached, and all known variable intermediate and resulting
                    meshes are allocated temporarily.

                    No radiosity.
                    No dynamic shadows.
                    No shadow hypervolumes.
                    No shadow volumes.
                    No shadow z-buffers.

                    I wonder how this would be implemented without shader DX8,9.
                    As it thought the author in 1999...?

                    I look forward to coming out Unreal 1 source and when users will be think about this futures..




                        Originally posted by Tim Sweeney View Post
                        Open sourcing Unreal Engine 1 might be possible, but getting the source and dependencies into a releasable state would take a lot of cleanup effort that we just haven't been able to find time for. I hope we can do it someday!
                        Would it be possible for the community to have a go at it ? I think that would be really fun job to update it.
                        Machine Learning C++ Plugin
                        Lindenmayer System C++ Plugin


                          Interesting history information about unreal engine 1 released to the public.

                          Tim Sweeney

                          Legend: (blank) Need to do it
                          !! Important
                          + Done
                          ?? Look into this
                          X Decided not to
                          >> A heading
                          ==== Denotes a new working version

                          "History shows that users place a great deal of emphasis on binary compatibility."
                          -- Byte Magazine

                          The architecture for trinity is well underway, and it will be dramatically
                          better in many ways. In fact, this next generation has more distinction than
                          any before it, because it is the first of the transition from the pixel to
                          the texture mapped triangle. Assumptions change and new capabilities arise
                          beyond what a simple processor speed increase would have given. Pushing the
                          technology is a long way from over, trust me. -- John Carmack

                          "Even the strongest of men are crushed like bugs under the feet of time" -- Tran

                          "Unreal is super cool" -- Bill Gates

                          "But Microsoft has added a new wrinkle, a backup plan, that IBM did not: to
                          embrace any technology it perceives as a threat... It has taken us a few years
                          to realize the entire PC industry is just a value-added reseller for Intel and Microsoft."
                          -- Upside Magazine.

                          Human brain: 1,000,000,000 mips, 10,000 gigabytes of storage
                          PentiumPro: 200 mips, 2 gigabytes of storage
                          Moore's law: Microprocessors double in speed every 9 months.
                          -- Microprocessor report:

                          >>Notes for others

                          James & Dave:
                          All anim seqs need rate definition, default 30.
                          Please use mixed-case filenames for anything that is visible within UnrealEd,
                          such as meshes, scripts, and textures.

                          Art crue:
                          All texture names need to be globally unique.
                          Use as many common palettes as possible; performance will be best when there is a small
                          number of palettes in view, like 8-12.
                          We need a good font. Check out awesome Age of Wonders font.
                          Please use mixed-case filenames for anything that is visible within UnrealEd, such
                          as meshes, scripts, and textures.
                          Need icons for all actors classes.

                          Major subsystem work to do

                          Running into wall sounds / feedback hooks
                          Scraping along wall sounds / feedback hooks
                          Floor surface roughness feedback hooks
                          Floor footstep sounds
                          Floor surface hurt

                          UType's replace CPT_'s for complete generic typing.
                          UDatabase = scriptable dynamic array of UType's.
                          Solve fragile base class problem by loading/saving with class/name for vars and
                          stack node indices.
                          Multiactor spawning hierarchies?

                          Triggerable lights, bTempLightingChange.
                          Zone name text messages
                          Overall brightness scaling value for screen!
                          First mesh texture is script replaceable by resource (doable).

                          >>Input system.
                          Intellimouse support.
                          Joystick axis support.
                          Joystick buttons support.
                          Other DirectInput device support.

                          >>Object manager.
                          UResource owners, like root? Would solve name resolution problems and provide scoping.
                          Ultrascrutinize resource file format.
                          Use hash as resource name starting point.
                          No GC geditor.currenttexture/class, etc. by doing USubsystem.
                          Current GC setup will toss resources that were referenced by
                          records that are held only within the transaction tracker. To
                          avoid this problem, the transaction tracker must serialize all
                          database items (via pointer to item <<serialize function).

                          >>D3D junk.
                          Create Z-buffer BEFORE IDirect3DDevice!
                          Am I in a non-d3d mode?
                          This sucks.
                          Allocate Z-buffer before querying for device.
                          Full flatshaded rendering.
                          Software rendering in a window
                          Software rendering DirectDraw
                          Software rendering DirectDraw on 3dfx
                          Direct3D fullscreen
                          Direct3D fullscreen on 3dfx
                          Direct3D fullscreen on NEC PowerVR
                          3dfx Glide fullscreen
                          OpenGL in a window
                          Fullscreen modes (select to launch)
                          FindRenderDevice -> CreateRenderDevice

                          >>AJudge actor type.
                          Contains rules about letting players enter/leave including approving
                          their persistent stats and accepting/rejecting them.
                          Contains network play rules.

                          Must must must must do floor reflections from a floorsurf pvs, oh yes!
                          If do mirrors, do water refraction.
                          Caustic overlay textures!
                          Gary's lazy evaluation rendering trick for dynamic
                          shadows by prerendering lightviews and filtering.
                          Volumetric fog with too many lightsources crashes.
                          Lattice code must max/min clip Z to within X% on high slopes to prevent vmetric errors.
                          Must worst-axis subdivide to reduce lattice sizes!
                          Try specular bump mapping with regular lights based on
                          viewer's direct angle-off-texture-to-light.
                          Account for truecolor, intermixed lightsources.
                          Also handle lattice effects like flickering.
                          Can palette table code efficiently handle Num<Max palettes?
                          Can palette table code account for smaller/larger shade ramps?
                          Add a TextureInfo to GBlit and use it in common between software/hw rendering.
                          Ground fog! Yes yes yes yes yes!
                          Laser site weapon, handled in fog and in point illuminataion.
                          Optimizations - n*log n is a LOT less than n*n!
                          Temporal oversampling possibilities
                          Optimize SetupForPoly (1.2 msec for nothing)
                          Dirty shadows alignment problem? Shadow fuzz visibility problem? Coplanar crack problems?
                          Can solve all of these problems with NoMerge tag, and pre-raytrace merging of all
                          identical iSurfs, even those coming from different brushes. Followed by separate
                          merging of all identical iLightMeshes (only care about coplanarity and data size,
                          not absolute alignment).
                          Raytracer point out of polygon rejection and nearest-shadow/light propagation?
                          Span buffer encoding and decoding
                          Span buffer encoding and decoding instead of mask map?
                          FSpanBuffer:ecodeFrom(const BYTE *Stream); // Assumes StartY,EndY already set
                          FSpanBuffer::EncodeTo(BYTE *Stream);
                          dword: num bytes comprising decompressed span buffer
                          word: num empty spans
                          word: num nonempty spans
                          7-byte start/end, 0x7e = must use word start/end, start&0x80 = empty row, end&0x80=end of row,
                          0x7d = clone previous row exactly.
                          Savings: Save space whenever: Avg span/unspan length > 16, or row is identical to last row, or row is empty.
                          Shadow map and illum map, use the span buffers!
                          How much time is wasted in matrix inversion? Worth caching?
                          Rewrite chunk filtering code
                          - Use new dynamics classes
                          - Figure out lighting in split zones
                          - Figure out span merging strategy
                          Proper rebuild order:
                          1. Rebuild geometry excluding detail brushes
                          2. Rebuild and optimize Bsp
                          3. Rebuild detail brushes (adds & subtracts), performing coplanar overlays for subtraction
                          Creature optimizations
                          Shared-side rasterizer setup
                          Build clipping span buffer rather than current awful raster clipping hack
                          Optimize for speed
                          Spanline z-buffer em
                          Sunbeam effects like polybounded volumetric lights.
                          Radiosity precomputation.
                          Volumetric spotlights.
                          Volumetric ground fog.
                          Texture refraction coefficients.
                          World cube sky option in addition to sky sheets.
                          Infinite distance sprites like sun, moon.
                          Two separate sky textures, top and bottom.
                          Rope sprites.
                          Store light mesh tetrisization information, to save mucho space.
                          FLightMeshIndex iLightActor: inefficiencies due to a hardcoded limit
                          of lights per surface: eats up a lot of memory but is still limited.
                          How about storing a variable length list, and building an additional
                          linked list at dynamic lighting time.
                          Generate light mesh info when adding a surface to the BSP; trim it after
                          BSP rebuild.

                          WeaponCalcView is limited. Should:
                          Call for each thing in the inventory
                          Draw each thing that returns a 1 from CalcView, as it returns it
                          This allows for dual weapons, cool powerups, mutliple active inventory items
                          Need weapon freeform movement option
                          h & vseek function, returns iPotentialTarget or INDEX_NONE
                          AutoVSeek & AutoHSeek based on bProjTarget
                          Projectiles need Hit and HitNotify logic
                          Compute ray/actor-sphere intersection and do the appropriate pyrotechnics spawns

                          >>Extreme compression.
                          * Break up point components into unique floats (within a threshold),
                          index them into a table, and huffman compress them by frequency, explicitly
                          storing the very infrequent ones.
                          * RLE the shadow maps and huffman compress them by run length.
                          * FIF the textures and their mips.
                          * Delta compress all actor classes wrt their parent class.
                          * Delta compress all databases wrt the previous.
                          * Eliminate duplicate brushes and things.
                          * Can probably get 5:1 compression overall.

                          >>Volumetric lighting extras.
                          Tag leaves with v-light idynamics and manage list of active v-lights as traverse
                          bsp from front to back, with stats.
                          Implement polygon-sphere-cone rejection, or reject with simple sphere--plane
                          intersection per span (side of plane reject, passthrough reject), with stats.
                          C dual light and fog code with full darkening integration.
                          Mask overflow problems with zmin/zmax checking.

                          >>Moving brushes.
                          Test moving brush ambient sounds
                          Test doors that don't exist on particular net levels or difficulty settings
                          Moving brush view in UnrealEd
                          Moving brush trains, setforward/setreverse/on/off/toggle
                          Implement MoverBump sensing
                          Build list of newly-encroached actors as add brush
                          ReturnWhenBump & stuff
                          MT_TriggerCycleOn, MT_TriggerCycleOff, MT_Instant, MT_Destruct?
                          Gyrate by period option (for lights & such!)
                          Test moving brush fillup conditions
                          Send shoot msg to shot moving brushes
                          Perfect brush/player interaction
                          Slave brushes = huge moving brush optimization (4X faster for iris doors)
                          Raytrace world brush nowhere option.
                          Really need an "Edit Brush" option for texturing the brush (COOL!)
                          Edit current brush, Edit level brushes, Use current brush
                          Show moving brushes properly in UnrealEd
                          Clean out moving brush stuff before csg, loads, saves
                          Re-add moving brush stuff after csg, loads, saves
                          Mover proximity stuff - don't fool with actor sphere, just place refs at all leaves
                          below owned nodes and use Touch messages with slightly enlarged radius.
                          Articulated cumulative rotation/movement slave brushes???

                          >>Networking (handed over to Mark).
                          Weird TcpDaemon idea.
                          LevelInfo could spawn TcpDaemon actors as TCP connections are started/ended on a port.
                          Slow TcpDaemon to TcpDaemon function calls like RPC.
                          Desired player type spec for entering a level as something.
                          DPlay UI, code
                          WinSock UI, code
                          Pending connection UI clean
                          Simple 1-level server
                          Multithread server
                          Proper player recognition, join (with limits), abandon, timeout
                          Full chat
                          SpawnPlayActor sense net mode & spawn into playerstart farthest from opponent player team
                          SpawnPlayActor handle whether player fits or not, handle optional team name & teleporter name

                          Build list of visible, nonstatic actors
                          Sort by priority first, then by class
                          Build packet of draw types, stopping when filled
                          Update sent actor counters

                          Delete nonstatic actors after expiry time
                          Unpacketize packet, merging actors based on uniqueness
                          Use AUnknown class

                          FireEngine support.
                          Animating texture support.

                          Handle same-level URL's
                          Handle other-local-level URL's
                          Stub [unreal:][//]server[/[level]] URL's
                          Spawn Web browser on http:// ??

                          >>Level brushes = actors w/ associated breps/bsps? Cool for editability, one less thing to track.
                          Can store brushes as classes
                          CSG_Add, CSG_Subtract, etc.
                          Brush selection popups (map edit mode & non) for setting properties
                          Quake-like entity stuff, no bizarre brush list hacks

                          >>Game logistics
                          Idle state, begin, end, pause - via GEngine.Pause()
                          Implement demo
                          Load/save game, load level + proper resource purge

                          >>UnrealEd projects
                          Outline editor.
                          Outline revolver, extruder, path extruder.
                          Implement FMeshUV sharing by breaking out FMeshUV into a separate resource.
                          Make note of when verts with common texture violate
                          New editor features:
                          - Brush "source" is always saved for each brush; this is
                          the solid-builder's base parms for solid-builder brushes,
                          or the 2d outline for 2d editor brushes. There is no source for
                          imported, intersected, or deintersected brushes.
                          - Solid builder logic -> UnrealScript?
                          New editor modes:
                          - Move individual brush vertex.
                          - Draw brush clipping line.
                          - Draw event connector.
                          - Draw 2D outline which is automatically extruded?
                          New commands:
                          - Group actors/brushes.
                          - Subtract one brush from another brush?
                          Texture properties
                          Sound properties
                          .BMP importer/exporter
                          External tools
                          Doom Importer
                          Quake importer
                          Quake exporter?
                          2D lofter
                          Rewrite using plain outline editor paradigm?
                          Extra functions
                          UnrealEd online help
                          HTML help format
                          Expand docs in all important areas
                          UnrealEd color prefs
                          UnrealEd -> UnrealStudio?
                          Eventually need drag box and brush grouping, group showing/hiding?
                          Need Edit Brush option! Yeah!
                          * Better brush stretching functions for making brushes fit.
                          * 2D shape editor - no diagonals, great gridsnap, vertex deletion,
                          simple Doom features.
                          * Post "add to world" solid editting--I.E. take a column and beam and group
                          them together--pull vertices around to change their configuration.
                          * Cutting and pasting (being able to select a group of solids and copy them to
                          a new loacation w/o having to draw them in mid-air and de-intersect-save-etc....
                          * The ability to edit any brush at any time.
                          * Quick resizing of any brush with a mouse drag. (Lets you quickly match the
                          length of a brush with another, or avoid filling any dialogue boxes.)
                          * Clipping planes. (Creating a plane with 3 points, then using it to subtract
                          a portion of the selected brush on one side of the plane.)
                          * Vertice manipulation of 3D brushes.
                          * Clipping can be used to make *any* shape brush in seconds. Absolutely no
                          restrictions. Clumsy subtractions are never necessary.
                          * Don't try anything but BSP. BSP has every bit of functionality of the other
                          editors, plus a ton more. (Including clipping!) It is also the most stable
                          of the bunch. (It hasn't crashed on me since v.12a)
                          * Edit-brush option: Vertex manipilation, retexturing.
                          * In any 2-d window, 2 or 3 'clipping points' can be placed with shift-right
                          click. If 2 are placed, then the 3rd point for the clipping plane lies on
                          the visible line created by the first 2 points, in whatever 2d view you are
                          placing them. After these points are placed, BSP shows only what lies to
                          one side of the plane that is created by these 3 points. (The 'normal' of
                          the plane can be flipped with a button, causing the other side of the brush
                          to be missing.) At this point, any of the clipping points can be moved in
                          any of the 2-d windows, altering the clipping plane, as well as the selected
                          brush. Once you have it exaclty like you want, just hit the clip button.
                          BSP actually deletes the old brush and puts the new one in its place. There
                          is no information saved on the actual 'subtraction' process.
                          * Subtraction actually changes the target brush, instead of placing
                          'subtraction' brushes. Yes, intersect/deintersect actually chages the brush
                          too, but only for the current brush. Revision is a huge part of editing!

                          Main loop
                          Start in clean, no-level play state (later demo loop etc)
                          Space = load & start level
                          Load game & save game 100% in all cases
                          Add res file based on *one* name/type; only adds that and its dependents?
                          Macro system for cramming multiple levels and Classes.ucx stuff together
                          Auto purge always work
                          Save game, load game with purge
                          Dehack camera levels
                          Dehack edsrv levels

                          Gfx ideas:
                          Dynamic shadows antialiased via sublimation
                          Alpha-blended texture type using palette
                          Edge antialiasing
                          Palette entries that are not lit by lookup table (how to do in 24-bit?)
                          Lens flare
                          Light highlight via alpha-blended sprite
                          Underwater 3-way blur
                          Sheafs of span-z light fading in and fading out
                          Corona of light visible through water surface
                          Xmas lighting
                          Volumetrically lit fog with proper Z-clipping

                          >>Game ideas:
                          Girders with high-res masked textures
                          Huge spider with thick legs
                          Flashlight, perhaps gun-mounted
                          Actor shadows via cone sampling
                          Weapon powerups, including getting two of a kind of weapon
                          Weapon body mounts, i.e. side cannons
                          Create playerview mesh for all nonhuman morph targets
                          Stolen Quake hammer
                          Moonlight-shining-through-rain lighting effect
                          Rain volumetric effect?
                          Bots on equal terms with players - same movement primitives?
                          Team play: Devil takes the highmost play (dead players can't reincarnate until
                          only one team or player is left alive).
                          Team skins; if you don't want to d/l em you get the defaults. Separate from resource system.
                          Spawn other creatures to attack your opponents (friendly to own team).
                          Indestructable admin players, can become invisible etc.

                          >>Edge renderer
                          Hedge links
                          Perfect ael clipping and sorting
                          Debug checks from hell

                          Perfect ael z realization, z-shading
                          Ael span generation
                          Ael silhoette edge resorting
                          Perfect nonconvex volume rendering
                          Perfect portal rendering
                          Optimize everything like hell!

                          >>New bsp pass:
                          35% of all points are near duplicates (within 0.2 units of each other), many of the others aren't
                          relevant if they are only intrasurface!
                          640x400: 11.5 msec; 320x200: 9.5 msec: This code is cache and geometry bound.

                          Generate leaf numbers in leaves.
                          Generate new format leaf side lists with duplicate removal.
                          Special case portal surfs.

                          60% of time is spent in GRender.GetPoint, 60% of points are cached!
                          10%-20% of all lines are clipped depending on the scene.
                          <0.5% of all lines are multiply clipped.

                          2 classes of edges - static edges whose relative depth sorting does not change,
                          and floating edges whose relative depth sorting can change. Handle each separately
                          and merge them per scanline?

                          Unordered flatshaded rendering.
                          Unordered flatshaded rendering with proper clipping.
                          Clip via per-surface effectiveness count.
                          Clip via inherent start/end effective count.
                          Unordered span buffer building.
                          Z-aware span buffer building.
                          100% pixel-perfect.

                          * Merge surfaces.
                          * Merge light meshes.
                          * Run 1/2 unit wielding pass.
                          * Each bsp leaf is a cv containing polys and portals.
                          * Bsp heuristic adjusted to minimize added portal sides while balacing the
                          tree half decently.

                          Phase 2.
                          * Massively high-level optimized and tested in full unoccluded Jorus.
                          - Perform minimum possible sorting (bucket or myqsort) or, better yet, avoid.
                          - Perform minimum possible surface transformation and work, save stuff in Surf
                          area for later usage.
                          - Perform very fast front/back test.
                          - Very fast subpixel accuracy.
                          - Integrated point and vector transformation.
                          - Outcode rejection.
                          - Use vertical exact intersection if that's fastest.

                          Phase 3.
                          * Portal rendering with faulting.

                          Phase 4.
                          * Rebuild for play option.
                          * Bsp portal generation and extraside minimization.
                          * No redundent edge setup.
                          * 0.5-unit point merging with dead-surface elimination.
                          * Duplicate side elimination.
                          * Superduo edge resolution.
                          * Surface merging.
                          * Lightmesh merging.
                          * 640x400 Jorus always <= 3.0 msec occlusion on PPro-200.

                          Phase 5.
                          * Integrated creature feelers and creature occlusion rendering.

                          >>New rendering technique notes
                          New stats: Performance is now a function of 2 things: pvedges and vsurfs
                          (not counting dynamic lighting and gameplay processing).
                          pvedges reflects the number of "potentially visible edges" in the view;
                          you can reduce it by occluding your levels and building simpler architecture.
                          vsurfs is the number of visible surfaces in the view; reduce it by using
                          simpler brushes and building simpler architecture.
                          Polygon counts aren't relevant because Unreal knows not of polygons.
                          Note that the editor and game use a very different rendering algorithm (use
                          the "optimize for game" option in the rebuilder to optimize a level for
                          gameplay rendering). The game's is much faster but is not versatile enough to
                          be edited. However, you're always just a rebuild away from either format.
                          Semisolids are no longer needed or supported.
                          Zones and portals are now useful only for setting ZoneDescriptor properties;
                          they don't speed up (or slow down) the engine anymore.

                          Things to ponder

                          * In Fourier theory convolution in the space domain is equivalant to
                          multiplication in the frequency domain. One can perform collision checking
                          using just a point by convolving the world with the collision volume of an
                          object. Is there a representation of polygon objects that is analogous to
                          the frequency domain of a signal, which would enable easy convolution of
                          the world?

                          * Is there a way to perform texture mapping directly from a texture stored in
                          its frequency domain? If so, this would be an extremely powerful technique
                          - Filtering quality would be ideal, because there would be no bilinear/bicubic
                          - Antialiasing would be ideal, since the source texture could simple be
                          convolved (multiplied) by an anisotropic filter kernel which is a function
                          of the current texel's distance, orientation, and slant from the viewer.
                          - Microtexturing would be natural, because a microtexture could be applied with
                          a different tile size than the source texture.
                          o(n*m) per pixel method:
                          - It is trivial to perform slow fourier synthesis texture mapping simply by
                          computing the n*m cos terms of the fourier expansion for each point.
                          - The n*m method could be accelerated by following the n*m cosine terms
                          along the rational linear path corresponding to a scanline. Mathematically
                          this can be accelerated by using a cos lookup table, or by using the
                          cos(a+b)=cos(a)sin(b)-cos(b)sin(a) expansion where [or something like that]
                          cos(a+b*t) can be determined with a sqrt but no cos/sin terms.
                          o(n+m) per pixel method:
                          - Perform a simple separation of variables and perform 1D fourier transforms.
                          o(??) per pixels methods:
                          - Use the FFT to reduce computational complexity.
                          o(a*b) method:
                          - The sinc filter analogy of this is the basis of more traditional anisotropic
                          texture filtering methods.
                          Is this tractable in realtime?

                          * Volumetric lighting.
                          - Clip spherical integration to arbitrary shapes like cones.
                          - Clip spherical integration to a polygon-bounded hull or BSP using boundary raytracing.
                          - Integrate a cone function.

                          * Audio.
                          - Precompute a raytraced or radiosity-like solution to the sound dampening/echoing problem
                          per node/zone, taking into account room geometry and absorptivity of materials/material
                          families and interpolate between adjacent nodes/zones as the player walks along. This
                          would require convolving the output sound stream by the precomputed filter. Is this
                          tractable in realtime?

                          Here it is: Recently, style sheets were introduced
                          to the web. They allow web sites to write some basic HTML, and
                          then reference a separate file that applys a style (like
                          all headers are green witha black background, etc.) If you want to change the style of your web site, you just
                          reference a new style sheet. - all of your web content stays the same.(the actual text.) My idea is this:
                          why not have a similar concept in UnrealEd?

                          Environment postprocessing - adding things like snow/moss/damage to levels based on
                          algorithms. Very applicable to terrain, perhaps also to regular geometry.

                          •You should be able to see yourself. Look to the side, you see your shoulder. Look down,
                          you see your feet. You fire downward... make sure not to blow your toes off!
                          •Guns, ammo, powerups, etc... actually *LIE* on the floor, not hovering there spinning and
                          making you wonder what keeps them up. Yes, this does occasionally make them harder to see,
                          but that would make it more interesting
                          •In multiplayer, you can actually _see_ what weapon your opponent carries, and base your
                          tactics on that knowlege, rather than waiting till he fires. That is too often
                          fatally too late.
                          •For the next generation of games: the water reflects slightly
                          •Enemies, when gibbed, leave their gibs behind, rather than Quake's rampant heads (or,
                          leaves a random body part behind)
                          •Deformation of walls when hit (at the very least, sprite bulletholes, etc...) 'Twould
                          be very cool: you fire tarydium at a wall. Some stick into it, while others shatter, leaving
                          tarydium dust and shards on the floor).

                          Fix the friggin zone bugs
                          searchlights should upd in UnrealEd
                          Camera w/ player controls w/o focus sucks CPU time
                          Import loses panning bug
                          Turning player controls on then off screws up some dyn lite fx in UnrealEd Sky8 well
                          fix counter %i

                          Past work log entries are in TimOld.txt


                          + Inoxx bug fix day
                          + fixed click on the texture to reselect , the properties text has disappeard (Inoxx)
                          + Fixed physProjectile bug (Steven)
                          + Fixed alt key sucking in camera views in UnrealEd (Inoxx).
                          + Fixed bug not being able to type 'z' in script editor! Ack! (Steven)
                          X BTW is it possible to prevent the game to autosave when playing with ctrl - P ?
                          X And when in DirectDraw. No.
                          + 'H' toggles hide-actors. BTW a key would be cool to toggle: hide/show actors. (Inoxx)

                          X the geometry is screwed, strange , both brushes come from 2D editor
                          X no 3ds brushes here Attachment Converted: f:\eudora\attach\BUG3.T3D
                          X -> 2d editor sometimes creates bad brushes (don't use them).

                          + Open free camera: dynamic light, no brushes, no movers, yes actors. (Inoxx)


                          X Using keyboard and mouse at the same time (like walking and moving the
                          X heap up ) generate some weird effect , is look not smooth at all moving with
                          X keyboard only is perfectly smooth , moving with mouse only is perfectly smooth
                          X too, but the both at the same time is ugly : Fixed

                          + Whenever I type a Z in unrealed, it does an undo (as if it was a ctrl-Z)...

                          + The green colors are still here when coming from directdraw mode. (Inoxx)

                          X In the Properties dialog box, when you input a string, it parses it out
                          X to only the first word unless you specifically put ("") quotes around it
                          X when inputting the data. -> No, this was fixed after 0.84.

                          + I'm not able to import Extreme. (Inoxx) Works now.

                          + Portals not displayed. (Test.unr)

                          X Why is the saving so slow? is it a bug or a feature? (Inoxx) -> Feature.

                          + Only one sprite chunk is hardware-rendered. On hardware, render source
                          + points unclipped. Fixed, but sprites suck. Use meshes wherever possible.

                          + Subclass and edit new is broken.

                          X Sometimes the textures browser is replaced by a camera view. (Inoxx) Can't duplicate.
                          + WM_MOUSEWHEEL -> AXIS_MouseW

                          + Pressing mouse right button AND up or down moves the player's head.

                          + Made the frigging orthogonal view backdrop white again.
                          + Extended MoveActor and TestMoveActor with IgnorePawns boolean.
                          + RotateActor.
                          + MoveActor handle moving hierarchy.

                          X Negative lights, for spawning post-explosions. Bleah! Looks awful.


                          + It appears that AnimEnd is never called for animations that only have one
                          + frame. Is this true? And is that what you intended? (jschneider) Fixed this bug.

                          X 3dfx support: I do get weird white triangles and lines flashing on the
                          X screen occasionally, as well as lockups after running around for a
                          X minute or so. (total lock) I don't know what else to tell you about
                          X this one, happens in any map that has decent size and it just freezes
                          X like it is taking a screenshot. (Cliff) Broken hardware!

                          + When save 'light', get error untagged name (Jason Emery). Fixed.


                          + Moving brush fixes.
                          + IsOverlapping.
                          + Movers must default to bBlocksActors, bBlocksPlayers!

                          X UActors: Derive from Primitive, and perform delegation of collision checks? Hmmm.
                          + Actor collision query function - optionally delegate to primitive.

                          + AActor::GetCollisionExtent: support movers properly.
                          + Fixed major array-through-context bug (Les Bird).

                          + Retest the suites.

                          + Replaced PF_IsFront, PF_IsBack with NF_IsFront, NF_IsBack, because there was
                          + a potential inversion problem with the BSP where polys are flipped relative
                          + to their coplanar node.

                          + Handle coordinate system transforms for.
                          + UModel::BoxLineCheck


                          + FYI: trying to spawn a null ('none') class will result in Unreal crashing.
                          + While reasonable, it would be nice if the spawn function just returned a
                          + null reference and maybe a warning. -> Fixed

                          X >- computer locks up totally (even Pview doesnt get you out of this one) when
                          X > clicking somewhere on the Rebuilder window.
                          X > this happens on all my computers, level loaded doesn't matter (freshly
                          X > installed 86v, loaded trying to click on BSP in the Rebuilder
                          X > window, CRASH) -> This does not sound like 0.864v!

                          + Fixed script compiler function-after-label-in-state crash.

                          + Export U, import U.
                          + Zone PlayerEvent!
                          + Clean up UnMath coords functions.

                          + Rotation variance of collision volume problem. Must actually transform collision
                          + BSP hulls and operate on the transformed versions (simply skipping the bounding
                          + boxes).

                          + Handle coordinate system transformation.
                          + UModel::PointCheck
                          + UModel::LineCheck
                          + UModel::BoxPointCheck

                          + Retest trace.

                          + Fixed major owner bug in MyBoxPointCheck.
                          + Separated iBound into iRenderBound and iCollisionBound.

                          + Space updates all views instead of ctrl.
                          + Fixed SerializeBin code.

                          + CPF_Intrinsic: Intrinsic actor properties, not touched by script?

                          + Eliminated hardcoded rendering dynamics limit.
                          X Resize rendering point and vector caches on the fly?

                          + Made curved surface technique 2x faster, and much smoother.
                          + Fixed UnrealEd not being movable when non-maximized.

                          + Environment mapped meshes.
                          + Actor bMeshEnviroMap with regular and curvy surfaces.
                          + EnvironmentMap texture per zone (get from parent).
                          + bZoneEnviro flag to use environment map surface from zone.
                          + Separated actor texture into Sprite, Skin.
                          X Option for 2-layer enviro mapping on 3d hardware. -> Looks like ****.

                          + BeginState/EndState probes.
                          + Fixed new trace bug, optimized Trace.

                          + 3dfx now supports all possible sizes of light meshes.
                          + 3dfx now supports modulation blended detail texture mapping.


                          + Test spawning over 3000 actors.
                          + 3dfx handle transparency and normalized 5551/565 textures.
                          + Must use chroma-keying for masked shadowed textures??

                          + Improved 3dfx masked/transparent shadowed textures.
                          + Optional glide fog diminishing.

                          + Fixed dynamic light sticking problem, 3dfx only.
                          + Fixed UnrealScript gotcha: Can't override a function and make it final.
                          + Import-and-add now selects all brushes AND all actors.


                          + Now BLACK is always treated as the mask color, not color 0. This greatly simplifies
                          + the artwork (no dpaint touchups).

                          + P & K keys - update all views! (Show icons!)

                          + Fix the zone code!
                          + Merged zone building code with visibility code.
                          + Zone finder must filter through both the front and the back.
                          + Portal code is now 100% totally general!
                          + Zones/portals can work for water now (but we still need swimming player controls)

                          + Clean up zone code.


                          3dfx questions
                          What's the deal with grDepthMask( DepthBuffering ) not working?
                          How to ping-pong the w-buffer?
                          3dfx requests for future hardware
                          Clamp rgba values to the (0-255) range at render time, so that they
                          can safely underflow or overflow within a specified range. Useful for
                          overbrightening and interpolating rational linear values (such as alpha
                          blended detail textures) where the range isn't bounded to 0-255.


                          + Zone extensions.
                          + Only split up polys (and use PF_NoMerge) if nonzero zones differ; right now it does way too much splitting.
                          + Opt geom after zone generation rather than before!
                          + Handle zones with semisolid invisible brushes cleanly. PF_Invisible now flows!
                          + Handle rendering zone portals with an actual texture (i.e. transparent).

                          + UnrealEd: Click on compile error on script whose window is not open crashes.
                          + UnrealEd water option use water zoning.

                          + Fixed rendering bugs with transparent portals.

                          X 3dfx should support zone ambient lights (affect palettes?) -> Software only!
                          + 3dfx can see detail texture lines during transition -> Now alpha-fade them in.
                          + 3dfx fade out transparent textures based on Z.
                          + Must make detail alpha persp-linear.

                          + Fixed .u loader -> However, the .ucx loader still needs work.
                          X Is there a way to do polygon filtering/splitting that's guaranteed to produce consistent results?

                          + LE_SpotLight now implements dynamic shadows.
                          + DrawScale should affect scaled sprites!

                          + Optimizations.


                          + Fixed moving brush position bugs.
                          + Cleaned up bounding volume code.
                          + Cleaned up the math code.
                          + virtual FBoundingBox UPrimitive::GetBoundingBox( AActor *Owner )
                          + Changed GetUncoords to ToWorld.
                          + Changed GetCoords to ToLocal.
                          + UMesh::BoundVisible properly handles all rotation.

                          + Improved AActor::GetCollisionExtent.
                          + Extended UPrimitive.

                          + Moved cylinder collision code to UPrimitive.
                          + Properly use UPrimitive::GetBoundingBox and eliminate TransformedBound dependence in code.
                          + Use for generalized actor bounding boxes.
                          + AActor::GetPrimitive.
                          + Eliminated bCheckCollision.

                          + GetData, Element on a const object imply const data.
                          + STEVE: NOTE: SetActorZone now takes a Test parm to indicate whether to send messages.
                          + Cleaned up MoveActor, FarMoveActor.

                          + Eliminated the "Engine" keyword for functions - it's obsolete.
                          + New "intrinsic(0)" declaration and EX_ProcessFunction enable you to call old AActor::Process
                          + style functions regardless of whether they reside in C++ or script code.
                          + SNODE_EditableState
                          X Enable mover ::Process intrinsics to be called from script.
                          + Timer() now takes no parameters.
                          + Fixed TransformPlaneBy bug!
                          + Optimized 3dfx code to reduce palette/texture churning.


                          Notes for steven:
                          When you need to kill an actor after a certain amount of time, just set the life span
                          rather than using a timer and destroying the actor manually.
                          Should all actors perhaps default to bEnginePhysics=true?
                          Don't use BoxPointCheck yet, it's still broken.
                          UnrealEd now includes a pulldown-list for setting an actor's initial state; to make a
                          state changeable in UnrealEd, just declare it like this:
                          state() MyState {...}
                          instead of
                          state MyState {}
                          Can you merge in my PlayerCalcView code for the behind-the-player view?
                          We need to be wary of infinite-recursive problems when we use Move from within
                          a Touch/Bump notification. I ran into this problems with the following script,
                          and James ran into it with some of his projectile code. Check out the new
                          function "singular" specifier - you can use it with notification functions like Bump
                          to prevent recursion.

                          class NewTrigger expands Trigger;
                          function Bump( actor Other )
                          // This recurses infinitely when called by Human.
                          log( "I was bumped by " $ Other.Class );
                          Move( Normal(Other.Location - Location) * 10.0 );


                          class NewTrigger expands Trigger;
                          var int RecursiveCount=0;
                          function Bump( actor Other )
                          if( ++RecursiveCount == 1 )
                          log( "I was bumped by " $ Other.Class );
                          Move( Normal(Location - Other.Location) * 10.0 );

                          Bug fix in execLineOfSightTo: *Always* validate parameters passed to C++ code from script code
                          and handle incorrect parameters gracefully. It should be impossible to crash the engine by
                          writing a buggy script, except for the case of infinite recursion. For example, actor pointers
                          with NULL before calling functions that expect actor parameters. Applicable functions:

                          static void execLineOfSightTo( FExecStack &Stack, UObject *Context, BYTE *&Result )


                          *(DWORD*)Result = Other ? ((APawn *)Context)->LineOfSightTo(Other) : 0;
                          AUTOREGISTER_INTRINSIC( AI_LineOfSightTo, execLineOfSightTo);

                          See also:

                          + New UnrealScript "state() StateName" notation makes a state settable within UnrealEd, which
                          + enables level editors to override the default state. UnrealEd now includes some interface
                          + improvements in the actor property editing code to facilitate this.

                          + Added SNODE_IteratorFunc.

                          + Moving brushes, use regular physics rotating code.
                          + MoveActor move floors.

                          + Settable state combo box in UnrealEd.

                          + Renamed "Floor" to "Base" for clarity.


                          + Rearranged execution stack in anticipation of vf hashing.
                          + FStackNodeLink overhaul.

                          + Changed FStackNodeLink to FStackNodePtr, now use pointer semantics.

                          + You can no longer override a non-final function with a final function. This is an optimization.
                          + Fixed decompiler bug with accessing properties through actor casts.
                          + Cleaned up FNestInfo.

                          + Don't allow calling iterator functions directly.
                          + Multiple recompiles & loads chokes the vftable freer?
                          + Extended FStackNode to include two parent pointers, ParentItem and ParentNest.
                          + Cleaned up the decompiler.

                          + Fixed bug in new mover intrinsics which conflicted with Steven's intrinsics.
                          + Added in checking for duplicate registered intrinsics.


                          + UnrealScript SNODE_SingularFunc to prevent reentrance on a per-actor basis, bSingularFunc.

                          + The new UnrealScript "singular" attribute can be applied to functions, to prevent them from
                          + being reentered. When a singular function is called in an actor, and another singular function
                          + is already being executed recursively in that actor, the later singular function returns
                          + immediately without doing anything. This mechanism exists to prevent infinite-recursive
                          + situations such as can occur when an actor tries to move in response to a "Bump" notification.

                          + Intrinsic vector MirrorVectorByNormal(vect,normal);

                          + Added physPathing, physMovingBrush.
                          + Removed PHYS_Splining.

                          // Here is a cool test script.
                          class Popcorn expands Trigger;

                          function BeginPlay() {
                          Physics = PHYS_Projectile;
                          bEnginePhysics = true;
                          bBounce = true;
                          bHidden = false;

                          singular function Bump( actor Other ) {
                          Velocity = Normal(Other.Location - Location) * 400.0;

                          singular function HitWall( vector Normal ) {
                          Velocity = MirrorVectorByNormal( Velocity, Normal );

                          + Finished up virtual function hashing. Whew!

                          + My physics modes.
                          + PhysAlpha, PhysRate -> Root. Negative rate is ok.
                          + PHYS_MovingBrush.
                          + PHYS_Interpolating.
                          + InterpolateEnd notification.
                          + latent FinishInterpolation();


                          + InterpolateBrushTo();
                          + Moved all the brush intrinsics to UnrealScript.

                          + Fixed big huge bug in UnrealScript which caused function parameters to be
                          + mismatched when bytes are passed as parameters.

                          + Fixed triggers!
                          + 'Begin:' label in states is now optional.
                          + Sorry, I eliminated NoName. Use '' instead.
                          + Scripted all of the new moving brush modes.
                          + New: In ULevel::MoveActor, bump messages are *not* send to an actor's base when the actor
                          + bumps it. This prevents a flurry of unnecessary messages.
                          + Moving brush sound effects.

                          + A state that overrides a state (of the same name) in its parent class inherets all of the
                          + functions and labels in that parent state. The syntax is unchanged.
                          + New: A base state can now inherent from another state in the same class. The syntax for this is:

                          state MyBaseState

                          state MyNewState expands MyBaseState

                          + IsState now returns whether an actor is in the specified state. This may return a different
                          + result than (Actor.State==TestState) because an actor may inheret from a parent state with
                          + a different name.

                          + Note that states can have either no inheretance or single inheretance. There
                          + is no way to do handle multiple inheretance (or "interfaces") with states.

                          + Pawn.Message command.


                          + Fixed UnrealScript problem compiling code like "RotationArray[Index].Pitch".
                          + Actor movement code now automatically updates moving brushes.
                          + Make sure Touch & Bump messaging is done with movers.

                          + New ResetTrigger mechanism for synchronizing mover-trigger-switches and the movers they control.
                          + New BumpButton moving brush type! Awesome.


                          + Iterators.
                          + NAME_ForEach

                          + Compiler support for iterators.
                          + Latent function calls are not allowed inside iteration loops.
                          + Loading/saving scripts with iterator tokens.
                          + Iterator decompiler.
                          + Can break out of a foreach.
                          + Can return from a function in a foreach (EX_IteratorPop first).
                          + Cannot goto into or out of a ForEach.
                          + Iterator compiling finished.

                          + Created all intrinsic stubs.
                          + Script compiler automatic typecasting of out object to BaseClass.

                          + Fixed zones Merged in extreme.


                          + Fixed Trace.

                          + Script execution support for iterators.
                          + Implement AllActors.
                          + At end of iteration, iterator variable should be set to None.

                          EX_Iterator + [wOffset End] + Iterator function call

                          + Iterators.
                          + execAllActors
                          + execChildActors
                          + execBasedActors
                          + execTouchingActors

                          X Allow casting strings to names. -> Would violate the UnrealScript sandbox.
                          + More iterators.
                          + execRadiusActors
                          + execZoneActors


                          + Merged Steven's code.

                          + Test & fix
                          + UModel::PointCheck
                          + UPrimitive::PointCheck
                          + UModel::BoxPointCheck
                          + UPrimitive::BoxPointCheck

                          + Torture test the actor destroying code.

                          X ScriptConst not inhereted?
                          X ScriptConst as delete-optimization? -> No can do.
                          X Test enforcing ScriptConst.

                          + Optimized UnrealScript virtual functions.

                          + Teleporter bStatic=false.
                          + Trace now takes bNoPawns parm.

                          + Require names enclosed in ''.
                          + Stubbed in the new mesh collision routines.

                          + Trace now takes flags to indicate what to check collision with.

                          + Merged Ammon's sound code.
                          + execVisibleActors
                          + UnrealEd music click on ".." must bring up song.

                          + All pawns must default to bCanTeleport=True.
                          + Seeing: check bHidden!

                          + Brush collision must work with brush prepivot/postpivot.

                          + Clean up model PreSubtract, PostAdd.
                          + Clean up AActor::ToLocal, AActor::ToWorld.


                          + Fix BoxPointCheck out normal. 1 = no hit, 0=hit.
                          + BoxPointCheck now fulfills Steve's wildest dreams and fantasies.

                          + Update from Steven.
                          + FCoords::Inverse() is 16 times faster.
                          + FCoords::Inverse now properly inverts the origin.
                          + Handle proper sheering of movers.

                          + Eliminate bEnginePhysics.
                          + FarMoveActor needs to set OldLocation.

                          + Objects are getting touch messages with themselves.
                          + Weapons curvy?
                          + Creature masking.

                          + Simplified Trace: FCollisionHash::LineCheck now can optionally handle the level actor.
                          + Expanded IsBlockedBy to handle the level actor and bCollideWorld properly.
                          + Simplified MoveActor.

                          + All of the collision functions now take an FVector Extent (instead of height & radius) for
                          + simplicity and generality.

                          + Eliminated PointCheck, LineCheck: Now use BoxPointCheck and BoxLineCheck with an extent of
                          + FVector(0,0,0) to do this. This keeps the interface cleaner.

                          + Implemented foreach TraceActors(), but no zone change notifications yet.
                          + This is a really cool function!

                          + Somehow merge node flags and trace flags into some kind of "solid volume classification flags"?
                          + Fixed walking through actors problems.
                          + Fixed walking through level problems.
                          + Tightened up LineCheck: Should be rock-solid now!

                          + Hash line check take optional "check level" flag.


                          + Clean up class intrinsicness and capitalization.
                          + Need working playerstarts.
                          + Get rid of .mac macros.

                          + Start spawned actor names at ClassName1.
                          X All drawscales should be 1.0.

                          + Implemented AActor::IsBasedOn.
                          + Tightened up SpawnActor code for cameras.
                          + Cleaned up moving brush code.


                          + Get rid of hardcoded \unreal paths in the scripts.
                          + Extended PlaceActor to handle actors.
                          + Improved math cosine and sine consistency.
                          + Merged with James & Steven.
                          + Use Skin texture for texture #0 if specified.

                          + Fixed the collision hash bug from hell.
                          + Property flags like Const now propagate through structure references!
                          + This created a collision bug with code like Location.Z += 9;
                          + See CPF_PropagateFromStruct.

                          + Split UPrimitive::GetBoundingBox into GetRenderBoundingBox, GetCollisionBoundingBox.
                          + UnLevAct: Rotate if < 0.5
                          + Verify mesh collision sizes.
                          + Fix trace flag handling.
                          X Trace still needed? Is ForEach with a Break better? -> It's nice for performance.

                          X Fix CollisionTrace.
                          X execCollisionTrace
                          X Test CollisionTrace for the behind-view.
                          X Eliminated CollisionTrace.

                          + ULevel::SetState: Don't send BeginPlay messages or other stuff if already up for play?
                          + Eliminate UnrealScript CollisionTrace intrinsic.

                          + Trace: optional vector Extent
                          + TraceActors: optional vector Extent

                          + Check out steve's t3d: unrdm1.t3d

                          + STEVE: I no longer need sizeof(AScriptedPawn)==sizeof(APawn), so feel free to go back to
                          + sticking variables in AScriptedPawn.
                          + If I were smart I would eliminate remembered-actors reconciliation!
                          + UnrealEd Double clicking on state combo doesn't advance.
                          X MoveActor take optional rotation for optimization. -> Separating these two things is nicer.
                          + Add collision extent to Trace.

                          + SpawnActor templates are no longer supported: Too problematic.
                          + Audio.
                          + Gracefully handle negative DrawScale.
                          + FScreenBound
                          + FScreenLocation

                          + DrawScaledSprite

                          + AMover EncroachingOn
                          + function bool EncroachingOn( actor Other );
                          + function EncroachedBy( actor Other );
                          + Fixed BoxCheck owner problem


                          + InterpolationPoint.
                          ? Illegal span range errors.
                          + Delete key is back in.
                          + Vital for E3.
                          + bInterpolating.
                          + Rotation or not depeding on physics.
                          + bDirectional.
                          + Option to do rate by RateModifier.
                          + Flyby support.
                          + Bogus script warning when GotoState with no state.
                          + James logging owner.rotation.pitch / yaw / roll bug. Non-bug.


                          + Event lines are back in UnrealEd.
                          + Ship1c import bug. Brush is screwed up beyond repair.
                          + Movers no longer take the shortest rotation path between their
                          + keyframes. They follow the rotation you specified in UnrealEd, including
                          + windings.

                          + Return values aren't copied out of intrinsics.
                          + Calling UnrealScript from C++ doesn't handle return values.
                          + Undo textures isn't synched with rebuild.

                          + Copy Inv.u InvCalcView1 to InvCalcView1.
                          + NOTE TO SELF: Never ever ever store redundent information that must be maintained.

                          + SinglePointCheck
                          + CheckEncroachment


                          Steven: Notable changes...
                          * Pawn.u: Trigger and Untrigger now take an Instigator parameter (the compiler catches this).
                          * UnLevel.h: MoveActor now takes NewRotation. Use Actor->Rotation for no rotation.

                          + Trigger messages need an instigator.
                          + Mover EncroachDamage.
                          + Fixed that DirectDraw problem!
                          + Test all mover reverse cases.
                          + Mover encroach damage.
                          + Added new NewRotation parameter to MoveActor. Just use Actor->Rotation to not rotate.
                          + Eliminated RotateActor.

                          + New UnrealEd progress bar & status bar - should be more stable.
                          + Changed compile shortcut keys to be in line with VC++/VJ++.

                          + BeginSlowTask
                          + Fixed up d3d code.
                          + Proper spawn tag!

                          X Input system keeps keys held on overflow?
                          X Test ResetInput. These seem to be weapon bugs.
                          X 3dfx backfaced masked polys like skaarj dreads are backface rejected. -> Mesh not set up for masking.
                          X Way to make a moving brush into a zone?
                          X Properly interleave timers with animation and movement?


                          + Fixed bug in probes - probe functions aren't reenabled properly when you are in a
                          + state but the probe function is global.
                          + Added cool new triggerable light class!
                          + Actor InterpolateEnd.
                          + Should be able to duplicate moving brushes.
                          + Slave movers.
                          X MouseLook with triggerpaths.
                          + NF_TagForEmpty change.
                          + Encroaching problems? Test3.
                          X Little animation interpolation problems with weapon - James noweeninto?

                          + Fix moving brush sounds.
                          + UnrealEd scrolls line out of view.

                          + Fixed windows asynchronous keyboard input problem! Controls are much better!
                          + GetKeyboardState

                          + 3dfx status bar died.
                          + Everyone's maps.


                          + Fixed moving brush ambient moving sound not stopping.
                          + REND CURVY toggles curved surface rendering.

                          + 3dfx texture panning.
                          + Improved software-rendering mipmap smoothing.
                          + Augh.unr - lighting bug with invisible collision brushes.
                          + Light <-> Convex volume association via portal clipping.

                          + In 3dfx fullscreen when you press the stupid windows key you lose control.
                          + Spline pathing.


                          + Quick optimizations.
                          + FindSpot = slooow!
                          + FCollisionHash::PointCheck was ignoring bActors.
                          + Hash objs by name & type.
                          + Added "SERVER RESTART" command.
                          + Bind.mac defaults.
                          + Caps lock toggles mouse look.

                          + bRestartLevel
                          + ObjectHashOf

                          + Actor spawning slowness?
                          + Fixed MergeNearPoints error.

                          + Slap on the hud.

                          Leaf-reject based on radius.
                          Reflective marble floors?

                          Leaf lights.
                          Sky. 2 parallaxing backdrop textures.
                          Handle light extent.
                          Handle volumetric extent.
                          Truecolor creature lighting - diffuse and phong attenuated by brightness.

                          UObject::Kill problems on exit.
                          Subtle light pulse option: LT_SubtlePulse.
                          Brushes weirdly rotate back to starting position when they encroach.

                          Restart-the-level option!
                          3dfx dynamic lighting optimization?

                          Triggerable ambient sounds.
                          Ole auto error still happens in VB with autosave. Nice and isolated now, though!

                          Moving down into trigger on moving brush
                          Wavy use fake sinus-panning on 3d hardware.

                          FarMoveActor must separate the standing actors from its base,
                          and separate the current actor from its base.
                          When encroach, attempt to move out. Or, multiaxis rotation with standing actors
                          needs to handle the actor box size when rotating?
                          Set bIsPlayer is set at spawn time when spawning a camera actor.

                          Status bar code.
                          Add mesh interpolation toggle.

                          bFire held when mouse firing?
                          DirectSound focus bug? Augh!
                          D3D needs work.
                          Snapback to level.
                          Key to snap back to level.


                          // Next actor in status bar.
                          var StatusInfo Next;

                          // The actor who is responsible for updating this StatusInfo.
                          var actor Controller;

                          // Textures.
                          var(Textures) texture Textures[16];
                          var() float TexStartX [16], TexEndX[16];
                          var() float TexStartY [16], TexEndY[16];

                          // Fonts to draw on top. Menu items are first.
                          var() font Fonts[12];
                          var() string[40] FontText[12];
                          var() float FontStartX[12], FontEndX[12];
                          var() float FontStartY[12], FontEndY[12];

                          // Information.
                          var() enum EStatusPosition
                          } StatusPosition;
                          var() int Priority; // Priority, 0=least important, 3=most important.
                          var() float StackSeparation; // Separation when stacking items.
                          var() int MenuDefault; // Default menu item number.
                          var() int MenuMax; // Maximum items in menu.
                          var() int ScaleHeight; // Local scaling.
                          var() int ScaleWidth; // Local scaling.

                          // Status.
                          var int MenuCurrent; // Current menu item.
                          var bool bInputFocus; // Has input focus.
                          var bool bMustRedraw; // Must recompose the texture.
                          var bool bVisible; // Whether to draw this.
                          var bool bTransparent; // Whether it's transparent.

                          // Regenerate the status bar.
                          function Regenerate();

                          Status bar issues:
                          Background textures in status bar.
                          Status bar expanding/contracting.
                          Pawn possess must create / destroy StatusBar.
                          Handle menus automatically as part of StatusBar.
                          Bind up, down, enter to keys for menus?
                          How to handle multiple views w/ different resolutions in netgames?
                          Menu & status bar data must be rez 1ndepedent.
                          Inventory thumbnails.
                          Active weapon ammo


                          Hub transitions.

                          When you have a brush I should use bCollideWorld instead of bCollideActors and
                          use Bump instead of Touch. Test with RazorJack.

                          3dfx light brightnesses.

                          UPrimitive GetRenderBoundingBox handle sprites?
                          Do brush visibility and conditional updating with sprite code! Then moving them
                          will be essentially free!


                          0.868 import notes:
                          When importing from 0.84:
                          See 0.864v import notes.
                          When importing from 0.864:
                          DrawScale= to Ignore=


                          ForEach TraceActors should check for zone transitions! Yeah!
                          ULevel::LineCheck needs zone accumulation option.
                          Need UnrealScript PointCheck function to classify point & zone.
                          ULevel::PointCheck needs list option.


                          Killing a dynamic light in gameplay doesn't cleanup its stuff.
                          Killing any light in UnrealEd doesn't clean up its stuff.

                          Player walk out of slime/lava leave green dynamic light trails.
                          DE: Detail textures.

                          Way of doing PlayAnim and tweening into a running sequence.

                          ResType 'ResTypeName' so I can merge Brush, Mesh, Model & Cylinder into Primitive.

                          Jitter problem when using both keyboard and mouse.


                          E3: 19th - 21st: Maybe:
                          Proper actor lighting.
                          Ground fog.
                          Volumetric lighting.
                          Actor shadows. is released on E3? If not, it is biggest failing Unreal.
                          Dynamic light shadows.
                          Inverse texture mapper for realtime dynamic light shadows and precomputed radiosity!


                          Pulse type light effect that goes entire range.
                          Bools to disable c&s player controls and rotation.
                          Negative lights!

                          Ability to tag creature polygons with DWORD PolyFlags, use frmPolyFlags.
                          No curve
                          Enviro mapped
                          Tag name like 'Head' etc.
                          class FSurfaceInfo
                          UTexture *Texture; // Texture map.
                          UPrimitive *Source; // From whence it came.
                          AActor *Owner; // Actor owning it.
                          FName Group; // Group.
                          FName Item; // Item.
                          DWORD PolyFlags; // Polygon flags.

                          Pancho's texture bug with nontiling textures.

                          When importing .u's, report resource related error messages more usefully.
                          It would be nice if resource loading failures during loading scripts appeared
                          in the script compilation window (so errors are more evident)

                          Delete classes: Make sure there are no references.
                          Delete texture set: Make sure there are no references.


                          Load/import class creates invalid junk in class browser.
                          SaveClass slow-task.
                          Compile/make slow-task? Eliminate results window?

                          More generalized way of keeping stuff around by its ULinkers.

                          Open map
                          Add file to map...
                          Texture set (.utx)
                          Sound set (.uax)
                          Class set (.ucx)
                          Music set (.umx)
                          ...Texture sets
                          ...Sound sets


                          Set up textures so DE can start experimenting with detail textures!
                          What's wrong with DepthBufferEnable?
                          3dfx volumetric lighting and ground fog.
                          Ping pong z buffer to eliminate the need for z clear?
                          Brightness/gamma setting.
                          Three-clip the textures for better detail clamping?
                          Generalize colored lighting code to support merge fx.


                          // Information about an object stored in (or imported by) this ULinker's
                          // UnrealFile.
                          class FStoredObject
                          // Variables.
                          UObject* Object; // Object in memory, NULL if not mapped into memory.
                          FName ObjectName; // Name of object.
                          FName ClassName; // Name of object's class.
                          ULinker* ImportFrom; // Linker to import it from, NULL = this one.
                          DWORD FileHeaderOffset; // Where this resides in this file, 0=imported.
                          DWORD FileHeaderSize; // File header size (for debugging only).
                          DWORD Flags; // Object flags.

                          // Constructors.
                          FStoredObject( UObject* InObject, DWORD InFlags, ULinker *InImportLinker )
                          : Object (InObject)
                          , ObjectName (InObject->GetFName())
                          , ObjectName (InObject->GetClass()->GetFName())
                          , ImportFrom (InImportLinker)
                          , FileHeaderOffset (0)
                          , FileHeaderSize (0)
                          , Flags (InFlags)
                          FStoredObject( UObject* InObject, DWORD InFlags, DWORD InFileHeaderOffset, DWORD InFileHeaderSize )
                          : Object (InObject)
                          , ObjectName (InObject->GetFName())
                          , ObjectName (InObject->GetClass()->GetFName())
                          , ImportFrom (NULL)
                          , FileHeaderOffset (InFileHeaderOffset)
                          , FileHeaderSize (InFileHeaderSize)
                          , Flags (InFlags)

                          // Save: convert ImportFrom linker.
                          // Load: Must be able to gracefully handle failing due to not locating the
                          // proper imports.

                          Construct linker object.
                          Load summary.
                          For each import in summary.
                          If file is a dll.
                          Verify that dll is found.
                          ElseIf linker doesn't already exist for file.
                          ConstructLinker(imported file).
                          Load names.
                          Build FStoredObject table.
                          If any ConstructLinker files, clean up gracefully - loading a file must
                          be able to fail cleanly if imports aren't ok.

                          If failed, skip gracefully.
                          Check that all objects in the file are properly imported.
                          If failed, skip gracefully.

                          Save in absolutely no specific order: loading is responsible for
                          sequencing things properly.

                          Update file tag.
                          App tag separate from file version.
                          Package tag?
                          Dependencies: Fully variable length, specify *location*.
                          Allow data areas of items to be expanded for forward compatibility via general functions.
                          File store minver, maxver for forward compatibility where applicable.


                          Scripts & intrinsics.
                          Set reverb & force parms when start, change zone, possess.
                          When change zones void ReverbParamsSet(INT Space, INT Depth);


                          New status bar rendering code.

                          Work out all actor naming issues, ability to rename individual actors in UnrealEd.
                          Before save-for-play, perform root make and validation step.
                          Save map files relative to the specified dependencies.

                          119-127, 196 234 235 236 237 238 239 240 241, 316+

                          FireEngine texture support and texture hierarchies including bump maps.


                          Unreal engine manifesto
                          UnrealScript language reference
                          Java style simplicity, object orientation, and compile-time error checking
                          Rich, Safe, High-level, slow
                          Object oriented
                          Time based execution
                          State scoping
                          Example program structure
                          General style (Java/C like, braces, semicolons)
                          The class declaration
                          Explain inheretance
                          Class specifiers
                          Base types
                          Objects and actors
                          Initializing variables
                          Editable variables
                          Regular, local, and static variables
                          Local variables
                          Return value
                          Virtual functions vs. Final functions
                          Explain latent execution of code
                          Explain state scoping and overriding of functions, labels
                          Editable states
                          Regular constants
                          String constants
                          Vector, Rotation constants
                          Object/Actor constants, None
                          Name constants, NoName
                          SizeOf, EnumCount, ArrayCount
                          Regular operators
                          Advanced operators
                          Accessing objects and actors
                          The . operator, explanation of null context handling
                          Vector, rotation . operator
                          Automatic promotion/demotion
                          Actor casts
                          Vector, rotation casts
                          Function calling
                          Explain state and class scoping
                          CallParent, CallGlobal, CallClass
                          Flow control
                          For, Do, While, Until, Break
                          If, Else If, Else
                          Select, Case, Default, Break
                          Labels and goto
                          ForEach and iterators
                          UnrealEd macro stream
                          Intrinsic functions
                          GotoState, Goto
                          Explain probes, Disable, Enable
                          Logging and debugging
                          Object related
                          Actor related
                          Destroy, describe latency issues
                          Explain concatenation
                          Technical overview
                          Garbage collected
                          Virtual machine interpretter
                          Interfacing with C++ code
                          Creating intrinsic classes, generating root.h
                          Calling C++ from UnrealScript: creating intrinsic functions
                          Calling UnrealScript from C++
                          Plugin DLL's
                          Unreal classes
                          bStatic meaning
                          Each major property category


                          Compiler speed is limited by property and UClass lookups! Duh!
                          Could include 16*2 property hash entries in class for 16x faster prop lookup.
                          Can hash resources by name/type.
                          Saving actors - Save properties as tagged deltas, so that actors can easily be
                          auto-upgraded in a typesafe way.


                          Perform initial touch testing.
                          Refuse to spawn if blocked.

                          Perform initial Touch, or UnTouch.
                          Refuse if blocked.

                          Perform Touch, UnTouch, succeed/fail.

                          UnrealScript CollisionTrace function.


                          Actors can either be owned by other actors or by Level (None is not an option?)
                          Then unowned actors would be in line for deletion.


                          Need simply animated textures (tex-00, text-01, etc).
                          UnrealEd def props - modify all actors if they are using default.


                          Volcano you go in - entrance to volcano!
                          Crater to walk down into.
                          Face anomaly like on Mars.
                          Strip mine with descending ramps - entrance to mine.
                          Lake shores.
                          Impassible rivers with bridges.


                          Safe recompiles.
                          After a compile, must postload and reimport the actorlist to refresh the
                          bin pointers or only do this at runtime and let UClass have its own
                          bin struct? Ugh. Maybe just need a RemapBin function to remap
                          properties from one class to another by name. Could keep the original
                          classes around (and rename after compile).


                          UnrealEd later.
                          Brush list merged into actor list.
                          Actors can be 'Locked' like brushes when map edit mode is off.
                          Cut and paste actors + brushes.
                          Easy grouping and auto zoning.
                          Support dragging cameras around like any other actors.


                          Thing that still suck in Unreal:
                          Global name scoping of all resources -> name scoping should be hierarchical, names optional.
                          Separation of the actor list and brush list -> Can merge them with a little work.
                          Terribly slow moving brush code -> Can fix with rendering rewrite.
                          Lack of grouping in UnrealEd -> Can add grouping pretty trivially.
                          Lack of 2d ops in UnrealEd -> Can add with 2-3 weeks of work.
                          Switch() approach to class properties -> Implement UType and UnrealScript struct command.
                          Unstructured editor modes, lack of mouse-movement feedback in the editing windows.


                          Also, I noticed that the 'autosave' feature pops up when Unrealed is out of
                          focus. Autosave is soo annoying at the moment, that I mostly disable it
                          from the start...

                          Tex brws can't handle long filenames with spaces. They import ok but you can't select them.

                          Tex brws "out of vm" bug - due to create dib section?

                          2. You should change the about box before the show. It still has the
                          old about box which says it will be published by EA (I doubt GT
                          Interactive will like that)

                          Don't allow creating actor classes w/ spaces in names.

                          24-bit color crashes.
                          Mesh viewer rotate.

                          Show sound radii in radii view

                          When adding portals, use no texture.
                          Alt-Tab DirectDraw maximization problem.

                          MergeNearPoints problem?


                            I always wondered what F prefix for non-UObject classes means in the Unreal Engine?
                            Realistic Atmosphere 2.0 | YouTube | Forum | Marketplace


                              What is meant a clean source?

                              For only rewriting code I could try help a clean source of release. It would be an honor for me.

                              I think is probably a lot of people who would like to help Epic with UE1 source.
                              It is the big unknown. What does UE1 mean for Tim? Source will want to go alone. Or cleanup enters someone else and he will work on UE5..
                              Last edited by Akyra; 06-24-2015, 07:31 AM.


                                Remember dynamic shadow on Riva TNT from Creative:

                                This is the future of computer gaming realism and it will be available to Unreal Engine licensees. Never not realized in UE1,UE2.. Shadows was in UE3, why so late?

                                Interesting is accordance:

                                Creative have licensed the Unreal Engine from us and have been doing some research in the area of both sound and graphics. They've already implemented a fantastic real-time creature shadowing technique using the Riva TNT's stencil-buffer capabilities.

                                Carmack's Reverse refers to a stencil buffer implementation of shadow volumes, which became a technique to become widely popular among video games following the 2004 release of Doom 3. Around 1999, a patent was filed that covers a "Method for rendering shadows using a shadow volume and a stencil buffer" and was then issued by the USPTO in 2002. John Carmack had independently conceived a similar algorithm to what's covered by the patent, which he created in the year 2000 while working on Doom 3. The patent in question is owned by Creative Labs.

                                Real-time shadowing by Crative wasnt used due to patent or rejection by Creative? or is it just a agreement fortuity?