No announcement yet.

Unreal Engine 1

  • Filter
  • Time
  • Show
Clear All
new posts

  • replied
    So nostalgic.

    Leave a comment:

  • replied
    Didn't realize I had a double post going on.

    Well, why not, I know a couple of peoples who are interested to expand UT99 engine to work with the latest technology to keep the game alive but also more than just that, to offer more variety of things to do in the game than what we can currently do. Even anti-cheat will have plenty of workaround, updated network technology (faster download are good, we may already have one from Higor's creation but what can be more there to improve?), and to improve other areas of the game which can use attention on such as graphic (Couple of peoples out there are a sucker for it, so why not let it work with the additional options in the newer machines?) for gameplay and weapons. There can be a whole lot more information to comply but I just posted a short info.

    Leave a comment:

  • replied
    Can someone explain to me why everyone wants to work into Unreal Engine 1's source? I can understand it if it's just a nostalgia and experimental thing, but (please, I am a mere peasant in this subject) how would it contribute to your modern work? I'm asking this out of curiosity and don't mean to offend or be rude.

    Leave a comment:

  • replied
    I'm interested to have the 436 source release @Tim

    Leave a comment:

  • replied
    I am interested to grab Unreal 1 source.

    Leave a comment:

  • replied
    Slowly approaching the end of the year. There will be a moment of free time over Christmas. What to look at the source Unreal 1.
    It is now download and edit an unofficial source ver. 400. It will be a problem when will be release this unofficial version Unreal engine the game? 17 years is a long wait.
    I think it's time to move forward.
    Last edited by Akyra; 10-27-2015, 07:21 AM.

    Leave a comment:

  • replied
    Originally posted by Tim Sweeney View Post
    We definitely can't open source Unreal Engine 2 or 3, because of dependencies on a large number of external closed-source middleware packages with complex licensing requirements.

    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!
    You could just release it As-is. The Fans could fix it?

    Leave a comment:

  • replied
    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?

    Leave a comment:

  • replied
    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.

    Leave a comment:

  • replied
    I always wondered what F prefix for non-UObject classes means in the Unreal Engine?

    Leave a comment:

  • replied
    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.

    + 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?

    Leave a comment:

  • replied
    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.

    Leave a comment:

  • replied

    Leave a comment:

  • replied
    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..

    Leave a comment:

  • replied
    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..

    Leave a comment: